Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

fix(desktop): improve setup, local startup and provider OAuth (#633)

David McKay6014b395d758
diff --git a/.github/workflows/desktop-signing.yml b/.github/workflows/desktop-signing.yml
index 7e7d53dc..8bf29d3c 100644
--- a/.github/workflows/desktop-signing.yml
+++ b/.github/workflows/desktop-signing.yml
@@ -118,6 +118,9 @@ jobs:
- name: Build and sign
env:
WINDOWS_SIGNING: keyvault
+ OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_ID: ${{ vars.OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_ID }}
+ OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_SECRET: ${{ secrets.OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_SECRET }}
+ OPENBOT_GOOGLE_MODEL_OAUTH_QUOTA_PROJECT: ${{ vars.OPENBOT_GOOGLE_MODEL_OAUTH_QUOTA_PROJECT }}
run: bun run tauri build --config src-tauri/tauri.windows-signing.conf.json --config src-tauri/tauri.build-version.conf.json --bundles nsis
working-directory: desktop
# Tauri restores the unsigned build output after bundling. Verify the app
diff --git a/.github/workflows/desktop.yml b/.github/workflows/desktop.yml
index 910ca05a..e2cf3a7d 100644
--- a/.github/workflows/desktop.yml
+++ b/.github/workflows/desktop.yml
@@ -10,6 +10,9 @@ on:
branches: [main]
paths: ["desktop/**", "package.json", ".github/workflows/desktop.yml"]
workflow_call:
+ secrets:
+ OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_SECRET:
+ required: false
permissions:
contents: read
@@ -101,6 +104,9 @@ jobs:
working-directory: desktop
env:
APPLE_SIGNING_IDENTITY: ${{ matrix.platform.name == 'macos' && '-' || '' }}
+ OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_ID: ${{ vars.OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_ID }}
+ OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_SECRET: ${{ secrets.OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_SECRET }}
+ OPENBOT_GOOGLE_MODEL_OAUTH_QUOTA_PROJECT: ${{ vars.OPENBOT_GOOGLE_MODEL_OAUTH_QUOTA_PROJECT }}
- name: Verify packaged Mac version and ad-hoc signature
if: matrix.platform.name == 'macos'
run: |
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3de25da3..8eea2f19 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,17 @@ Newest first. `Unreleased` is what is on `main` and not yet tagged.
## Unreleased
+### Desktop setup shows progress and works around occupied local ports
+
+Downloads show transferred bytes and elapsed time, Back preserves saved connections, and repair
+stays under Installation options after setup. OpenBot selects and remembers usable local ports,
+including when Windows reserves a default port. Setup can create a CopilotKit project and offers
+Google Gemini and xAI API-key choices, plus OAuth sign-in with automatic token refresh. Google
+OAuth requires the distributor's desktop client and quota-project configuration. Unsupported Bun
+installations are replaced with the pinned runtime; startup errors retain useful details and provide a configurable setup-help link.
+Docker image downloads can find the credential helper bundled beside Docker even when it is
+missing from the desktop app's PATH. Existing Docker credentials and helper preferences are preserved.
+
## 0.0.14
### A tool cannot be granted for an app this deployment has not added
diff --git a/agent-langgraph/tests/google-oauth-proxy.test.ts b/agent-langgraph/tests/google-oauth-proxy.test.ts
new file mode 100644
index 00000000..526a4e8a
--- /dev/null
+++ b/agent-langgraph/tests/google-oauth-proxy.test.ts
@@ -0,0 +1,134 @@
+import { expect, test } from "bun:test";
+import { RunAgentInputSchema } from "@ag-ui/core";
+import type { AIMessageChunk } from "@langchain/core/messages";
+import { ChatOpenAI } from "@langchain/openai";
+import {
+ googleRequest,
+ googleResponse,
+} from "../../server/src/google-oauth-transport";
+import { toLangChainMessages } from "../src/history";
+
+test("LangGraph streams and replays Gemini tool signatures through its actual SDK and AG-UI history", async () => {
+ const signature = `${"aBc012+/".repeat(512)}==`;
+ let calls = 0;
+ const nativeBodies: ReturnType<typeof googleRequest>["body"][] = [];
+ const server = Bun.serve({
+ hostname: "127.0.0.1",
+ port: 0,
+ async fetch(request) {
+ const converted = googleRequest(await request.json());
+ nativeBodies.push(converted.body);
+ calls++;
+ const parts =
+ calls === 1
+ ? [
+ {
+ functionCall: {
+ id: "native_browser_1",
+ name: "browser",
+ args: { url: "https://example.com" },
+ },
+ thoughtSignature: signature,
+ },
+ ]
+ : [{ text: "Page loaded." }];
+ return googleResponse(
+ new Response(
+ `data: ${JSON.stringify({ candidates: [{ content: { parts }, finishReason: "STOP" }] })}\n\n`,
+ { headers: { "content-type": "text/event-stream" } },
+ ),
+ converted.model,
+ true,
+ );
+ },
+ });
+ try {
+ const model = new ChatOpenAI({
+ model: "gemini-3.6-flash",
+ apiKey: "local-fixture-token",
+ configuration: { baseURL: `${server.url}v1` },
+ useResponsesApi: false,
+ maxRetries: 0,
+ });
+ const tools = [
+ {
+ type: "function" as const,
+ function: {
+ name: "browser",
+ parameters: {
+ type: "object",
+ properties: { url: { type: "string" } },
+ required: ["url"],
+ },
+ },
+ },
+ ];
+ let message: AIMessageChunk | undefined;
+ for await (const chunk of await model
+ .bindTools(tools)
+ .stream("Open example.com"))
+ message = message ? message.concat(chunk) : chunk;
+ const call = message?.tool_calls?.[0];
+ expect(call?.id).toBe(`native_browser_1__thought__${signature}`);
+ const history = RunAgentInputSchema.parse({
+ threadId: "fixture-thread",
+ runId: "fixture-run",
+ state: {},
+ tools: [],
+ context: [],
+ forwardedProps: {},
+ messages: [
+ { id: "user-1", role: "user", content: "Open example.com" },
+ {
+ id: "assistant-1",
+ role: "assistant",
+ content: "",
+ toolCalls: [
+ {
+ id: call?.id,
+ type: "function",
+ function: {
+ name: call?.name,
+ arguments: JSON.stringify(call?.args),
+ },
+ },
+ ],
+ },
+ {
+ id: "result-1",
+ role: "tool",
+ toolCallId: call?.id,
+ content: "The page loaded",
+ },
+ ],
+ });
+ let answer = "";
+ for await (const chunk of await model
+ .bindTools(tools)
+ .stream(toLangChainMessages(history)))
+ answer += chunk.content;
+ expect(answer).toBe("Page loaded.");
+ expect(nativeBodies[1].contents[1].parts).toEqual([
+ {
+ functionCall: {
+ id: "native_browser_1",
+ name: "browser",
+ args: { url: "https://example.com" },
+ },
+ thoughtSignature: signature,
+ },
+ ]);
+ expect(nativeBodies[1].contents[2].parts).toEqual([
+ {
+ functionResponse: {
+ id: "native_browser_1",
+ name: "browser",
+ response: { result: "The page loaded" },
+ },
+ },
+ ]);
+ expect(calls).toBe(2);
+ } finally {
+ server.stop(true);
+ }
+});
diff --git a/desktop/PROVIDER_OAUTH.md b/desktop/PROVIDER_OAUTH.md
new file mode 100644
index 00000000..7aaefd77
--- /dev/null
+++ b/desktop/PROVIDER_OAUTH.md
@@ -0,0 +1,69 @@
+# Model provider OAuth
+
+OpenBot's Google and xAI model connections are separate from signing in to
+OpenBot or CopilotKit. API keys remain available for both providers.
+
+## Google Gemini
+
+Google OAuth uses the Gemini Developer API and the selected Google Cloud
+project's API quota. It does not use a personal Gemini subscription. OAuth
+requests use Google's native generation API; the local server translates the
+existing agents' Chat Completions requests, streamed replies, tool calls and
+screenshots. API-key connections continue to use Google's compatibility API.
+
+Before distributing a configured desktop build, register a **Desktop app** OAuth
+client in a Google Cloud project with the Generative Language API enabled. Set
+these variables when building the desktop app to include its defaults. Runtime
+process environment variables can override those defaults:
+
+- `OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_ID`: that desktop client's ID.
+- `OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_SECRET`: the client secret, when issued.
+- `OPENBOT_GOOGLE_MODEL_OAUTH_QUOTA_PROJECT`: the project that supplies API quota.
+
+For GitHub-built artifacts, configure repository Actions **variables** named
+`OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_ID` and
+`OPENBOT_GOOGLE_MODEL_OAUTH_QUOTA_PROJECT`, plus an Actions **secret** named
+`OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_SECRET` when the client has one. Both the
+Desktop artifact workflow and the Windows signing workflow pass these settings
+to the native build. They become defaults inside the distributed desktop app;
+the desktop client credential is not a user access or refresh token.
+
+When calling the Desktop workflow as a reusable workflow, pass its optional
+`OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_SECRET` secret explicitly or use
+`secrets: inherit`. GitHub does not provide repository secrets to fork pull
+requests. Missing settings do not fail the build; API-key connections remain
+available, and Google sign-in requires a configured build or runtime settings.
+
+Do not reuse OpenBot's web SSO credentials (`GOOGLE_OAUTH_CLIENT_ID` and
+`GOOGLE_OAUTH_CLIENT_SECRET`): their callback and permissions serve a different
+purpose. Configure the consent screen and test users, and complete Google's
+verification requirements before wider distribution.
+
+References: [Gemini API OAuth](https://ai.google.dev/gemini-api/docs/oauth) and
+[Google desktop OAuth](https://developers.google.com/identity/protocols/oauth2/native-app).
+
+## xAI
+
+xAI sign-in uses device authorization: OpenBot opens the provider's verification
+page, the user approves the displayed code, and OpenBot receives refreshable
+credentials. API calls use `https://api.x.ai/v1`.
+
+The integration follows the public OAuth flow in xAI's endorsed OpenCode
+integration. A distributor can set `OPENBOT_XAI_MODEL_OAUTH_CLIENT_ID` to an
+alternative registered client. Account entitlements and provider limits still
+apply.
+
+References: [xAI's OpenCode integration](https://x.ai/news/grok-opencode) and
+[xAI OAuth discovery](https://auth.x.ai/.well-known/openid-configuration).
+
+## Credential lifecycle
+
+The desktop's provider credentials remain in its local deployment; React does
+not receive access or refresh tokens. The local server refreshes credentials
+before model calls and saves rotated tokens. Agent processes receive a local
+proxy credential instead of the provider's refresh token. Provider revocation
+requires signing in again.
+
+Do not commit deployment credential files or include their contents in support
+reports. OAuth validation must include a real model call, refresh and restart,
+and a Bot using its browser tool and rendering a graphical component.
diff --git a/desktop/src-tauri/capabilities/default.json b/desktop/src-tauri/capabilities/default.json
index d52d8c6e..d9f97e5a 100644
--- a/desktop/src-tauri/capabilities/default.json
+++ b/desktop/src-tauri/capabilities/default.json
@@ -3,5 +3,11 @@
"identifier": "default",
"description": "What the setup window is allowed to do. Commands this app defines are always callable; everything under core: is not, and has to be granted here.",
"windows": ["main"],
- "permissions": ["core:event:default"]
+ "permissions": [
+ "core:event:default",
+ {
+ "identifier": "opener:allow-open-url",
+ "allow": [{ "url": "https://*" }, { "url": "http://*" }]
+ }
+ ]
}
diff --git a/desktop/src-tauri/gen/schemas/capabilities.json b/desktop/src-tauri/gen/schemas/capabilities.json
index 48a6d5f9..c5e5647c 100644
--- a/desktop/src-tauri/gen/schemas/capabilities.json
+++ b/desktop/src-tauri/gen/schemas/capabilities.json
@@ -1 +1 @@
-{"default":{"identifier":"default","description":"What the setup window is allowed to do. Commands this app defines are always callable; everything under core: is not, and has to be granted here.","local":true,"windows":["main"],"permissions":["core:event:default"]}}
\ No newline at end of file
+{"default":{"identifier":"default","description":"What the setup window is allowed to do. Commands this app defines are always callable; everything under core: is not, and has to be granted here.","local":true,"windows":["main"],"permissions":["core:event:default",{"identifier":"opener:allow-open-url","allow":[{"url":"https://*"},{"url":"http://*"}]}]}}
\ No newline at end of file
diff --git a/desktop/src-tauri/src/engine.rs b/desktop/src-tauri/src/engine.rs
index 4b63842e..2754f497 100644
--- a/desktop/src-tauri/src/engine.rs
+++ b/desktop/src-tauri/src/engine.rs
@@ -221,11 +221,8 @@ impl Address {
/// because that file belongs to whoever else may have configured it.
pub fn command(&self) -> Command {
let (binary, arguments) = self.parts();
- let mut command = command(binary);
+ let mut command = command_at(self.engine, &binary);
command.args(arguments);
- if let Some(dir) = tools_dir() {
- command.env("PATH", path_with(dir));
- }
command
}
@@ -329,9 +326,48 @@ fn tools_dir() -> Option<&'static PathBuf> {
/// A command that runs this engine's binary, wherever it actually is.
pub fn tool(engine: Engine) -> Command {
- let mut built = command(program(engine).unwrap_or_else(|| PathBuf::from(engine.binary())));
- if let Some(dir) = tools_dir() {
- built.env("PATH", path_with(dir));
+ command_at(
+ engine,
+ &program(engine).unwrap_or_else(|| PathBuf::from(engine.binary())),
+ )
+}
+
+fn command_at(engine: Engine, binary: &Path) -> Command {
+ let mut built = command(binary);
+ let mut path = tools_dir()
+ .map(|dir| path_with(dir))
+ .or_else(|| std::env::var_os("PATH"));
+ if engine == Engine::Docker && binary.is_absolute() {
+ // A GUI can find Docker via its installation path while its PATH cannot find Docker's
+ // credential helper. Desktop ships them together, sometimes behind a CLI symlink.
+ // Append to preserve the person's chosen helpers and our Compose-provider precedence.
+ let resolved = std::fs::canonicalize(binary).ok();
+ for directory in [binary.parent(), resolved.as_deref().and_then(Path::parent)]
+ .into_iter()
+ .flatten()
+ {
+ let existing: Vec<_> = path
+ .as_deref()
+ .map(std::env::split_paths)
+ .into_iter()
+ .flatten()
+ .collect();
+ if existing.iter().any(|entry| entry == directory) {
+ continue;
+ }
+ // A directory containing the platform PATH separator cannot be represented here.
+ // Keep the original environment in that case; Docker still reports its real error.
+ if let Ok(expanded) = std::env::join_paths(
+ existing
+ .into_iter()
+ .chain(std::iter::once(directory.to_path_buf())),
+ ) {
+ path = Some(expanded);
+ }
+ }
+ }
+ if let Some(path) = path {
+ built.env("PATH", path);
}
built
}
@@ -528,6 +564,104 @@ fn socket_override(engine: Engine) -> Option<String> {
mod tests {
use super::*;
+ #[test]
+ fn docker_credential_helper_is_found_beside_resolved_cli_without_changing_config() {
+ if crate::test_support::isolated_process(
+ "engine::tests::docker_credential_helper_is_found_beside_resolved_cli_without_changing_config",
+ ) {
+ return;
+ }
+ let root = crate::test_support::temp_root("docker credential helper path");
+ let bin = root.join("Docker application/bin");
+ std::fs::create_dir_all(&bin).unwrap();
+ let source = root.join("fixture.rs");
+ let docker = bin.join(format!("docker{}", std::env::consts::EXE_SUFFIX));
+ let helper = bin.join(format!(
+ "docker-credential-desktop{}",
+ std::env::consts::EXE_SUFFIX
+ ));
+ std::fs::write(
+ &source,
+ r#"
+fn main() {
+ if std::env::current_exe().unwrap().file_stem().unwrap() == "docker-credential-desktop" {
+ println!("configured helper used");
+ return;
+ }
+ let filename = format!("docker-credential-desktop{}", std::env::consts::EXE_SUFFIX);
+ let path = std::env::split_paths(&std::env::var_os("PATH").unwrap_or_default())
+ .map(|directory| directory.join(&filename)).find(|path| path.is_file());
+ let Some(path) = path else {
+ eprintln!("docker-credential-desktop: executable file not found in PATH");
+ std::process::exit(41);
+ };
+ let output = std::process::Command::new(path).arg("get").output().unwrap();
+ assert!(output.status.success());
+ print!("{}", String::from_utf8(output.stdout).unwrap());
+}
+"#,
+ )
+ .unwrap();
+ crate::test_support::compile_fixture(&source, &docker);
+ std::fs::copy(&docker, &helper).unwrap();
+ let config = root.join("config.json");
+ let original = br#"{"credsStore":"desktop","credHelpers":{"private.example":"custom"}}"#;
+ std::fs::write(&config, original).unwrap();
+ std::env::set_var("PATH", root.join("gui-path-without-docker"));
+ let output = command_at(Engine::Docker, &docker)
+ .env("DOCKER_CONFIG", &root)
+ .output()
+ .unwrap();
+ assert!(
+ output.status.success(),
+ "{}",
+ String::from_utf8_lossy(&output.stderr)
+ );
+ assert_eq!(output.stdout, b"configured helper used\n");
+ assert_eq!(std::fs::read(config).unwrap(), original);
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn docker_symlink_adds_target_helpers_after_inherited_paths_and_managed_compose() {
+ if crate::test_support::isolated_process(
+ "engine::tests::docker_symlink_adds_target_helpers_after_inherited_paths_and_managed_compose",
+ ) {
+ return;
+ }
+ let root = crate::test_support::temp_root("docker symlink helper path");
+ let target = root.join("Docker.app/Contents/Resources/bin");
+ let links = root.join("usr/local/bin");
+ for directory in [&target, &links] {
+ std::fs::create_dir_all(directory).unwrap();
+ }
+ std::fs::write(target.join("docker"), "fixture").unwrap();
+ std::os::unix::fs::symlink(target.join("docker"), links.join("docker")).unwrap();
+ let inherited = root.join("custom-helpers");
+ let managed = root.join("managed-compose");
+ std::env::set_var("PATH", &inherited);
+ tools_live_in(managed.clone());
+ let command = command_at(Engine::Docker, &links.join("docker"));
+ let path = command
+ .get_envs()
+ .find(|(key, _)| *key == "PATH")
+ .unwrap()
+ .1
+ .unwrap();
+ let directories: Vec<_> = std::env::split_paths(path).collect();
+ assert_eq!(
+ directories,
+ [
+ managed,
+ inherited,
+ links,
+ std::fs::canonicalize(target).unwrap()
+ ]
+ );
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
#[test]
fn runtime_selectors_keep_the_existing_status_wire_shape() {
let mut address = Address::new(Engine::Docker, None);
diff --git a/desktop/src-tauri/src/env.rs b/desktop/src-tauri/src/env.rs
index b5b12a6e..2ee9a334 100644
--- a/desktop/src-tauri/src/env.rs
+++ b/desktop/src-tauri/src/env.rs
@@ -38,8 +38,8 @@ somebody switches away from the plan.
pub const CHATGPT_STORE_FILE: &str = ".langchain/chatgpt-auth.json";
pub const CHATGPT_STORE_INSIDE: &str = "/root/.langchain/chatgpt-auth.json";
-/// Ports the stack publishes. Matched to `docker-compose.yml` defaults so a person who later runs
-/// Compose by hand finds the deployment where the documentation says it is.
+/// Host ports, persisted in this deployment's .env and reused while they remain available.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Ports {
pub app: u16,
pub server: u16,
@@ -48,6 +48,7 @@ pub struct Ports {
pub bot: u16,
pub langgraph: u16,
pub supervisor: u16,
+ pub harness: Option<u16>,
}
impl Default for Ports {
@@ -60,10 +61,267 @@ impl Default for Ports {
bot: 4200,
langgraph: 4201,
supervisor: 4500,
+ harness: None,
}
}
}
+impl Ports {
+ pub fn read(root: &Path) -> std::io::Result<Self> {
+ let values = read_already_set(
+ &root.join(".env"),
+ &[
+ "APP_PORT",
+ "SERVER_PORT",
+ "POSTGRES_PORT",
+ "COMPUTER_PORT",
+ "BOT_PORT",
+ "LANGGRAPH_PORT",
+ "SUPERVISOR_PORT",
+ "PICKED_HARNESS_HOST_PORT",
+ ],
+ )?;
+ let mut ports = Self::default();
+ for (key, port) in [
+ ("APP_PORT", &mut ports.app),
+ ("SERVER_PORT", &mut ports.server),
+ ("POSTGRES_PORT", &mut ports.postgres),
+ ("COMPUTER_PORT", &mut ports.computer),
+ ("BOT_PORT", &mut ports.bot),
+ ("LANGGRAPH_PORT", &mut ports.langgraph),
+ ("SUPERVISOR_PORT", &mut ports.supervisor),
+ ] {
+ if let Some(value) = values.get(key) {
+ *port = parse_port(key, value)?;
+ }
+ }
+ ports.harness = values
+ .get("PICKED_HARNESS_HOST_PORT")
+ .map(|value| parse_port("PICKED_HARNESS_HOST_PORT", value))
+ .transpose()?;
+ Ok(ports)
+ }
+
+ pub fn settings(&self) -> BTreeMap<String, String> {
+ let mut settings: BTreeMap<_, _> = [
+ ("APP_PORT", self.app),
+ ("SERVER_PORT", self.server),
+ ("POSTGRES_PORT", self.postgres),
+ ("COMPUTER_PORT", self.computer),
+ ("BOT_PORT", self.bot),
+ ("LANGGRAPH_PORT", self.langgraph),
+ ("SUPERVISOR_PORT", self.supervisor),
+ ]
+ .into_iter()
+ .map(|(key, port)| (key.to_string(), port.to_string()))
+ .collect();
+ if let Some(port) = self.harness {
+ settings.insert("PICKED_HARNESS_HOST_PORT".into(), port.to_string());
+ }
+ settings
+ }
+
+ /// A connect probe misses Windows excluded ports: only a bind proves a port is usable.
+ /// Hold the probes until every port is chosen so allocations cannot collide with each other.
+ /// Existing containers from this exact Compose project are reusable, never foreign listeners.
+ pub fn available(
+ self,
+ ours: &std::collections::HashSet<u16>,
+ harness: Option<u16>,
+ ) -> std::io::Result<Self> {
+ let mut held = Vec::new();
+ let mut chosen = std::collections::HashSet::new();
+ let mut choose = |preferred, container: bool| -> std::io::Result<u16> {
+ if !chosen.contains(&preferred) {
+ if container && ours.contains(&preferred) {
+ chosen.insert(preferred);
+ return Ok(preferred);
+ }
+ if let Ok(listeners) = bind_loopbacks(preferred) {
+ held.extend(listeners);
+ chosen.insert(preferred);
+ return Ok(preferred);
+ }
+ }
+ let mut last = None;
+ for _ in 0..32 {
+ match bind_loopbacks(0) {
+ Ok(listeners) => {
+ let port = listeners[0].local_addr()?.port();
+ if chosen.insert(port) {
+ held.extend(listeners);
+ return Ok(port);
+ }
+ }
+ Err(error) => last = Some(error),
+ }
+ }
+ Err(last.unwrap_or_else(|| {
+ std::io::Error::other("could not allocate distinct local ports")
+ }))
+ };
+ Ok(Self {
+ app: choose(self.app, false)?,
+ server: choose(self.server, false)?,
+ postgres: choose(self.postgres, true)?,
+ computer: choose(self.computer, true)?,
+ bot: choose(self.bot, true)?,
+ langgraph: choose(self.langgraph, true)?,
+ supervisor: choose(self.supervisor, true)?,
+ harness: harness
+ .map(|default| choose(self.harness.unwrap_or(default), true))
+ .transpose()?,
+ })
+ }
+}
+
+fn parse_port(key: &str, value: &str) -> std::io::Result<u16> {
+ value
+ .parse::<u16>()
+ .ok()
+ .filter(|port| *port != 0)
+ .ok_or_else(|| {
+ std::io::Error::new(
+ std::io::ErrorKind::InvalidData,
+ format!("{key} must be a port from 1 to 65535"),
+ )
+ })
+}
+
+fn bind_loopbacks(port: u16) -> std::io::Result<Vec<std::net::TcpListener>> {
+ let ipv4 = std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, port))?;
+ let port = ipv4.local_addr()?.port();
+ let mut held = vec![ipv4];
+ match std::net::TcpListener::bind((std::net::Ipv6Addr::LOCALHOST, port)) {
+ Ok(ipv6) => held.push(ipv6),
+ Err(error)
+ if matches!(
+ error.kind(),
+ std::io::ErrorKind::AddrNotAvailable | std::io::ErrorKind::Unsupported
+ ) => {}
+ Err(error) => return Err(error),
+ }
+ Ok(held)
+}
+
+#[cfg(test)]
+mod port_tests {
+ use super::*;
+ use std::collections::HashSet;
+ use std::net::{TcpListener, TcpStream};
+
+ #[test]
+ fn occupied_ports_are_replaced_with_distinct_bindable_loopback_ports() {
+ let foreign = TcpListener::bind("127.0.0.1:0").unwrap();
+ let port = foreign.local_addr().unwrap().port();
+ let preferred = Ports {
+ app: port,
+ server: port,
+ postgres: port,
+ computer: port,
+ bot: port,
+ langgraph: port,
+ supervisor: port,
+ harness: Some(port),
+ };
+ let chosen = preferred.available(&HashSet::new(), Some(port)).unwrap();
+ let values: HashSet<u16> = chosen
+ .settings()
+ .values()
+ .map(|value| value.parse().unwrap())
+ .collect();
+ assert_eq!(values.len(), 8);
+ assert!(!values.contains(&port));
+ for value in values {
+ assert!(bind_loopbacks(value).is_ok(), "port {value} is unavailable");
+ }
+ assert!(
+ TcpStream::connect(foreign.local_addr().unwrap()).is_ok(),
+ "foreign listener must remain untouched"
+ );
+ }
+
+ #[test]
+ fn occupied_ipv6_port_is_not_treated_as_available_ipv4_port() {
+ let foreign = TcpListener::bind("[::1]:0").unwrap();
+ let port = foreign.local_addr().unwrap().port();
+ let preferred = Ports {
+ postgres: port,
+ ..Ports::default()
+ };
+ let chosen = preferred.available(&HashSet::new(), None).unwrap();
+ assert_ne!(chosen.postgres, port);
+ }
+
+ #[test]
+ fn saved_ports_survive_reopen_and_only_a_new_conflict_moves() {
+ let root = crate::test_support::temp_root("saved-local-ports");
+ std::fs::create_dir_all(&root).unwrap();
+ let chosen = Ports::default()
+ .available(&HashSet::new(), Some(4206))
+ .unwrap();
+ std::fs::write(
+ root.join(".env"),
+ "CUSTOM=kept\nOPENAI_API_KEY=synthetic-kept\n",
+ )
+ .unwrap();
+ write(&root.join(".env"), &chosen.settings(), &BTreeMap::new()).unwrap();
+ let reopened = Ports::read(&root).unwrap();
+ assert_eq!(reopened, chosen);
+ assert_eq!(
+ reopened.available(&HashSet::new(), Some(4206)).unwrap(),
+ chosen
+ );
+ let foreign = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, chosen.server)).unwrap();
+ let changed = reopened.available(&HashSet::new(), Some(4206)).unwrap();
+ assert_ne!(changed.server, chosen.server);
+ assert_eq!(
+ Ports {
+ server: chosen.server,
+ ..changed
+ },
+ chosen
+ );
+ let settings = std::fs::read_to_string(root.join(".env")).unwrap();
+ assert!(settings.contains("CUSTOM=kept"));
+ assert!(settings.contains("OPENAI_API_KEY=synthetic-kept"));
+ drop(foreign);
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
+ #[test]
+ fn own_published_container_ports_are_reused_but_do_not_authorize_host_port_reuse() {
+ let owned = TcpListener::bind("127.0.0.1:0").unwrap();
+ let port = owned.local_addr().unwrap().port();
+ let preferred = Ports {
+ postgres: port,
+ server: port,
+ ..Ports::default()
+ };
+ let chosen = preferred.available(&HashSet::from([port]), None).unwrap();
+ assert_eq!(chosen.postgres, port);
+ assert_ne!(chosen.server, port);
+ assert_ne!(
+ preferred.available(&HashSet::new(), None).unwrap().postgres,
+ port
+ );
+ }
+
+ #[test]
+ fn invalid_saved_ports_fail_instead_of_probing_an_unrelated_default() {
+ let root = crate::test_support::temp_root("invalid-local-ports");
+ std::fs::create_dir_all(&root).unwrap();
+ for value in ["0", "65536", "unknown"] {
+ std::fs::write(root.join(".env"), format!("SERVER_PORT={value}\n")).unwrap();
+ assert_eq!(
+ Ports::read(&root).unwrap_err().kind(),
+ std::io::ErrorKind::InvalidData
+ );
+ }
+ std::fs::remove_dir_all(root).unwrap();
+ }
+}
+
/**
The secrets this shell mints rather than being given.
@@ -133,6 +391,7 @@ pub fn compose(
"ANTHROPIC_API_KEY",
"CLAUDE_CODE_OAUTH_TOKEN",
"CHATGPT_AUTH_FILE",
+ "OPENBOT_MODEL_OAUTH_FILE",
"BOT_PROVIDER",
/*
* Retired, and cleared for exactly that reason. An earlier version put the ChatGPT
@@ -156,7 +415,10 @@ pub fn compose(
* Removed rather than emptied, so `docker-compose.yml`'s own default applies. Blank would
* be passed through as a model named "", which is a worse question to ask a provider.
*/
- if !matches!(model.credential, ModelCredential::Compatible { .. }) {
+ if !matches!(
+ model.credential,
+ ModelCredential::Compatible { .. } | ModelCredential::ProviderOAuth { .. }
+ ) {
for key in ["BOT_MODEL", "AGENT_BOT_MODEL"] {
env.remove(key);
}
@@ -196,6 +458,29 @@ pub fn compose(
env.insert("CHATGPT_AUTH_FILE".into(), CHATGPT_STORE_INSIDE.into());
}
}
+ ModelCredential::ProviderOAuth {
+ path,
+ proxy_token,
+ model,
+ ..
+ } => {
+ env.insert("OPENBOT_MODEL_OAUTH_FILE".into(), path.clone());
+ env.insert("OPENAI_API_KEY".into(), proxy_token.clone());
+ env.insert(
+ "OPENAI_BASE_URL".into(),
+ format!("http://127.0.0.1:{}/api/model-provider/v1", ports.server),
+ );
+ env.insert(
+ "OPENAI_CONTAINER_BASE_URL".into(),
+ format!(
+ "http://host.docker.internal:{}/api/model-provider/v1",
+ ports.server
+ ),
+ );
+ env.insert("BOT_PROVIDER".into(), "openai".into());
+ env.insert("BOT_MODEL".into(), model.clone());
+ env.insert("AGENT_BOT_MODEL".into(), model.clone());
+ }
ModelCredential::Compatible {
base_url,
container_base_url,
@@ -351,6 +636,7 @@ pub fn compose(
run_path,
remote_agent_id,
} => {
+ let host_port = ports.harness.unwrap_or(*port);
env.insert("PICKED_HARNESS_IMAGE".into(), image.clone());
env.insert("PICKED_HARNESS_PORT".into(), port.to_string());
env.insert("PICKED_HARNESS_NAME".into(), name.clone());
@@ -358,11 +644,11 @@ pub fn compose(
env.insert(
"PICKED_HARNESS_URL".into(),
if run_path.is_empty() {
- format!("http://127.0.0.1:{port}")
+ format!("http://127.0.0.1:{host_port}")
} else if run_path.starts_with('/') {
- format!("http://127.0.0.1:{port}{run_path}")
+ format!("http://127.0.0.1:{host_port}{run_path}")
} else {
- format!("http://127.0.0.1:{port}/{run_path}")
+ format!("http://127.0.0.1:{host_port}/{run_path}")
},
);
/*
@@ -411,13 +697,14 @@ pub fn compose(
format!("http://127.0.0.1:{}", ports.server),
);
- env.insert("APP_PORT".into(), ports.app.to_string());
- env.insert("SERVER_PORT".into(), ports.server.to_string());
- env.insert("POSTGRES_PORT".into(), ports.postgres.to_string());
- env.insert("COMPUTER_PORT".into(), ports.computer.to_string());
- env.insert("BOT_PORT".into(), ports.bot.to_string());
- env.insert("LANGGRAPH_PORT".into(), ports.langgraph.to_string());
- env.insert("SUPERVISOR_PORT".into(), ports.supervisor.to_string());
+ env.extend(ports.settings());
+ env.insert(
+ "OPENBOT_TOOL_URL".into(),
+ format!(
+ "http://host.docker.internal:{}/api/agent-tools/call",
+ ports.server
+ ),
+ );
// The whole deployment is on this machine, so the server must be allowed to talk to it.
//
@@ -562,6 +849,13 @@ pub enum ModelCredential {
build doc.
*/
ChatGptPlan { store: String },
+ /// A native-held OAuth session; the local proxy owns access-token refresh.
+ ProviderOAuth {
+ provider: String,
+ path: String,
+ proxy_token: String,
+ model: String,
+ },
/// Anything that speaks the OpenAI wire format, at an address the person gave.
///
/// Also where a signed-in ChatGPT plan lands, because that login yields a token and the address
@@ -1586,6 +1880,41 @@ HTTPS_PROXY=http://proxy:8080
"http://127.0.0.1:3999",
"a setting that is not a secret was carried forward and is now stale"
);
+ assert_eq!(
+ value_of(&written, "OPENBOT_TOOL_URL"),
+ "http://host.docker.internal:3999/api/agent-tools/call",
+ "container tools must call the selected API port"
+ );
+ }
+
+ #[test]
+ fn selected_harness_uses_dynamic_host_port_without_changing_image_port() {
+ let ports = Ports {
+ harness: Some(52106),
+ ..Ports::default()
+ };
+ let settings = compose(
+ &intelligence(),
+ &Model::default(),
+ &engine_status(None),
+ &ports,
+ &pinned(),
+ Some(&PickedHarness::Installed {
+ image: "synthetic:local".into(),
+ port: 4206,
+ name: "Synthetic".into(),
+ mastra: false,
+ run_path: "/ag-ui".into(),
+ remote_agent_id: String::new(),
+ }),
+ &BTreeMap::new(),
+ );
+ assert_eq!(settings["PICKED_HARNESS_PORT"], "4206");
+ assert_eq!(settings["PICKED_HARNESS_HOST_PORT"], "52106");
+ assert_eq!(
+ settings["PICKED_HARNESS_URL"],
+ "http://127.0.0.1:52106/ag-ui"
+ );
}
}
diff --git a/desktop/src-tauri/src/host_access.rs b/desktop/src-tauri/src/host_access.rs
index c74c43fb..9c4c5328 100644
--- a/desktop/src-tauri/src/host_access.rs
+++ b/desktop/src-tauri/src/host_access.rs
@@ -1653,6 +1653,15 @@ mod tests {
loop {
match listener.accept() {
Ok((mut stream, _)) => {
+ // Winsock accept inherits the listener's nonblocking mode.
+ // Only accept polls; each fixture request uses bounded blocking I/O.
+ stream.set_nonblocking(false).unwrap();
+ stream
+ .set_read_timeout(Some(Duration::from_secs(2)))
+ .unwrap();
+ stream
+ .set_write_timeout(Some(Duration::from_secs(2)))
+ .unwrap();
let mut reader = BufReader::new(stream.try_clone().unwrap());
let mut content_length = 0_usize;
loop {
@@ -1720,6 +1729,32 @@ mod tests {
}
}
+ #[test]
+ fn result_collector_accepts_delayed_fragmented_requests() {
+ let collector = ResultCollector::start();
+ let address = collector.base_url.strip_prefix("http://").unwrap();
+ let mut stream = std::net::TcpStream::connect(address).unwrap();
+ stream
+ .set_read_timeout(Some(Duration::from_secs(2)))
+ .unwrap();
+ stream
+ .set_write_timeout(Some(Duration::from_secs(2)))
+ .unwrap();
+ stream.write_all(b"POST /res").unwrap();
+ thread::sleep(Duration::from_millis(50));
+ stream
+ .write_all(b"ults HTTP/1.1\r\nHost: localhost\r\nContent-Length: 11\r\n\r\n{\"ok\":")
+ .unwrap();
+ thread::sleep(Duration::from_millis(50));
+ stream.write_all(b"true}").unwrap();
+ // Content-Length frames the response; a subsequent socket close is not part of it.
+ let expected = b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\n{}";
+ let mut response = vec![0_u8; expected.len()];
+ stream.read_exact(&mut response).unwrap();
+ assert_eq!(response, expected);
+ assert_eq!(collector.bodies(), vec!["{\"ok\":true}".to_owned()]);
+ }
+
fn temp_root(name: &str) -> PathBuf {
let path = std::env::temp_dir().join(format!(
"{name}-{}-{}",
diff --git a/desktop/src-tauri/src/install.rs b/desktop/src-tauri/src/install.rs
index 75a1a5fa..e451d415 100644
--- a/desktop/src-tauri/src/install.rs
+++ b/desktop/src-tauri/src/install.rs
@@ -215,8 +215,8 @@ fn ensure_bun_with(
install: impl FnOnce() -> Result<PathBuf, Problem>,
) -> Result<PathBuf, Problem> {
match existing {
- Some(path) => Ok(path),
- None => install(),
+ Some(path) if verify_bun(&path).is_ok() => Ok(path),
+ _ => install(),
}
}
@@ -338,7 +338,7 @@ fn extract_bun(archive: &Path, target: &Path, entry: &str) -> Result<(), Problem
Ok(())
}
-fn verify_bun(binary: &Path) -> Result<(), Problem> {
+pub(crate) fn verify_bun(binary: &Path) -> Result<(), Problem> {
let output = crate::quiet::command(binary)
.arg("--version")
.output()
@@ -992,11 +992,41 @@ mod tests {
#[test]
fn an_existing_bun_does_not_trigger_installation() {
- let existing = PathBuf::from("existing user runtime/bun.exe");
+ let root = temp_root("existing-pinned-bun");
+ let existing = runtime_version_fixture(&root, BUN);
assert_eq!(
ensure_bun_with(Some(existing.clone()), || panic!("already installed")).unwrap(),
existing
);
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
+ fn runtime_version_fixture(root: &Path, version: &str) -> PathBuf {
+ std::fs::create_dir_all(root).unwrap();
+ let source = root.join("runtime.rs");
+ std::fs::write(&source, format!("fn main() {{ assert_eq!(std::env::args().nth(1).as_deref(), Some(\"--version\")); println!({version:?}); }}")).unwrap();
+ let binary = root.join(format!("bun{}", std::env::consts::EXE_SUFFIX));
+ crate::test_support::compile_fixture(&source, &binary);
+ binary
+ }
+
+ #[test]
+ fn unsupported_existing_bun_acquires_pinned_runtime_without_changing_user_binary() {
+ let root = temp_root("unsupported-existing-bun");
+ let existing = runtime_version_fixture(&root.join("user"), "1.2.15");
+ let pinned = runtime_version_fixture(&root.join("openbot"), BUN);
+ let before = std::fs::read(&existing).unwrap();
+ let chosen = ensure_bun_with(Some(existing.clone()), || Ok(pinned.clone())).unwrap();
+ assert_eq!(
+ chosen, pinned,
+ "an incompatible user runtime must not be selected"
+ );
+ assert_eq!(
+ std::fs::read(existing).unwrap(),
+ before,
+ "the user's runtime is untouched"
+ );
+ std::fs::remove_dir_all(root).unwrap();
}
#[test]
diff --git a/desktop/src-tauri/src/intelligence.rs b/desktop/src-tauri/src/intelligence.rs
index 9d5dec2c..3c47911f 100644
--- a/desktop/src-tauri/src/intelligence.rs
+++ b/desktop/src-tauri/src/intelligence.rs
@@ -396,6 +396,51 @@ fn list_projects(product: &str) -> Result<Vec<Project>, crate::problem::Problem>
Ok(found)
}
+fn project_creation_body(name: &str) -> Result<serde_json::Value, crate::problem::Problem> {
+ let name = name.trim();
+ // Match the product API's existing POST /api/projects schema.
+ if name.is_empty() || name.encode_utf16().count() > 255 {
+ return Err(crate::problem::Problem::plain(
+ "Enter a project name between 1 and 255 characters.",
+ ));
+ }
+ Ok(serde_json::json!({"name": name}))
+}
+
+pub fn create_project(product: &str, name: &str) -> Result<Project, crate::problem::Problem> {
+ create_project_at(PRODUCT_API, product, name)
+}
+
+fn create_project_at(
+ api: &str,
+ product: &str,
+ name: &str,
+) -> Result<Project, crate::problem::Problem> {
+ let body = project_creation_body(name)?;
+ let response = client()?
+ .post(format!("{api}/api/projects"))
+ .bearer_auth(product)
+ .json(&body)
+ .send()
+ .map_err(|error| {
+ crate::problem::Problem::with("Your project could not be created.", error.to_string())
+ })?;
+ if !response.status().is_success() {
+ let status = response.status();
+ return Err(crate::problem::Problem::with(
+ "CopilotKit could not create that project. Check the name and try again.",
+ format!(
+ "HTTP {status}\n{}",
+ without_credentials(&response.text().unwrap_or_default())
+ ),
+ ));
+ }
+ let raw = read_json(response, "created project")?;
+ projects_in(&serde_json::json!([raw])).into_iter().next().filter(|project| !project.id.trim().is_empty()).ok_or_else(|| {
+ crate::problem::Problem::plain("CopilotKit created a project but did not return its ID. Sign in again to refresh the project list.")
+ })
+}
+
/// Whether a payload actually says "no projects" rather than saying something unrecognised.
fn looks_genuinely_empty(raw: &serde_json::Value) -> bool {
let rows = raw
@@ -530,6 +575,98 @@ pub fn projects_in(raw: &serde_json::Value) -> Vec<Project> {
#[cfg(test)]
mod tests {
+ #[test]
+ fn project_creation_trims_names_and_rejects_empty_or_overlong_names() {
+ assert_eq!(
+ super::project_creation_body(" Desktop test ").unwrap(),
+ serde_json::json!({"name":"Desktop test"})
+ );
+ assert!(super::project_creation_body(" \n ").is_err());
+ assert!(super::project_creation_body(&"x".repeat(256)).is_err());
+ assert!(super::project_creation_body(&"x".repeat(255)).is_ok());
+ }
+
+ #[test]
+ fn creates_project_using_the_signed_in_credential_and_parses_numeric_id() {
+ let (url, request) =
+ project_creation_server("201 Created", r#"{"id":42,"name":"Desktop validation"}"#);
+ let project =
+ super::create_project_at(&url, "synthetic-product-session", " Desktop validation ")
+ .unwrap();
+ assert_eq!(
+ project,
+ super::Project {
+ id: "42".into(),
+ name: "Desktop validation".into()
+ }
+ );
+ let (headers, body) = request.join().unwrap();
+ assert!(headers.starts_with("POST /api/projects HTTP/1.1\r\n"));
+ assert!(headers
+ .to_lowercase()
+ .contains("authorization: bearer synthetic-product-session\r\n"));
+ assert_eq!(
+ serde_json::from_slice::<serde_json::Value>(&body).unwrap(),
+ serde_json::json!({"name":"Desktop validation"})
+ );
+ }
+
+ #[test]
+ fn project_creation_preserves_api_failure_and_rejects_missing_id() {
+ for (status, body) in [
+ ("403 Forbidden", r#"{"error":"not allowed"}"#),
+ ("201 Created", r#"{"name":"No ID"}"#),
+ ] {
+ let (url, request) = project_creation_server(status, body);
+ let error =
+ super::create_project_at(&url, "synthetic-product-session", "Desktop validation")
+ .unwrap_err();
+ if status.starts_with("403") {
+ assert!(error.detail.unwrap().contains("HTTP 403"));
+ } else {
+ assert!(error.said.contains("did not return its ID"));
+ }
+ request.join().unwrap();
+ }
+ }
+
+ fn project_creation_server(
+ status: &'static str,
+ body: &'static str,
+ ) -> (String, std::thread::JoinHandle<(String, Vec<u8>)>) {
+ use std::io::{BufRead, Read, Write};
+ let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+ let url = format!("http://{}", listener.local_addr().unwrap());
+ let request = std::thread::spawn(move || {
+ let (stream, _) = listener.accept().unwrap();
+ stream
+ .set_read_timeout(Some(std::time::Duration::from_secs(5)))
+ .unwrap();
+ let mut reader = std::io::BufReader::new(stream);
+ let mut headers = String::new();
+ loop {
+ let mut line = String::new();
+ assert!(reader.read_line(&mut line).unwrap() > 0);
+ headers.push_str(&line);
+ if line == "\r\n" {
+ break;
+ }
+ }
+ let length: usize = headers
+ .lines()
+ .find_map(|line| {
+ let (name, value) = line.split_once(':')?;
+ name.eq_ignore_ascii_case("content-length")
+ .then(|| value.trim().parse().unwrap())
+ })
+ .unwrap();
+ let mut request_body = vec![0; length];
+ reader.read_exact(&mut request_body).unwrap();
+ write!(reader.get_mut(), "HTTP/1.1 {status}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len()).unwrap();
+ (headers, request_body)
+ });
+ (url, request)
+ }
/// The field name that broke a whole sign-in, read off the real response.
#[test]
fn the_session_is_read_from_the_name_the_endpoint_uses() {
diff --git a/desktop/src-tauri/src/lib.rs b/desktop/src-tauri/src/lib.rs
index b90fbc68..1699eae5 100644
--- a/desktop/src-tauri/src/lib.rs
+++ b/desktop/src-tauri/src/lib.rs
@@ -14,6 +14,7 @@ pub mod plan;
pub mod preparation;
pub mod problem;
pub mod provider;
+pub mod provider_oauth;
pub mod pull_metrics;
pub mod quiet;
pub mod saved_intent;
diff --git a/desktop/src-tauri/src/main.rs b/desktop/src-tauri/src/main.rs
index a2858d4c..ea766761 100644
--- a/desktop/src-tauri/src/main.rs
+++ b/desktop/src-tauri/src/main.rs
@@ -57,6 +57,8 @@ struct Shell {
last_failure: Mutex<Option<openbot_desktop_lib::problem::Problem>>,
/// Reading the notification must not make a partially running deployment adoptable again.
recovery_required: Mutex<Option<RecoveryRequired>>,
+ /// An explicit reset remains bound to the engine that found the leftover database.
+ leftover_database: Mutex<Option<LeftoverDatabase>>,
selected_root: Mutex<Option<PathBuf>>,
root: Mutex<Option<PathBuf>>,
/// Containers may outlive a failed Start before any host root is published.
@@ -93,6 +95,12 @@ struct ContainerDeployment {
address: engine::Address,
}
+struct LeftoverDatabase {
+ root: PathBuf,
+ volume: String,
+ address: engine::Address,
+}
+
struct RecoveryRequired {
root: PathBuf,
generation: u64,
@@ -191,6 +199,9 @@ struct Progress {
step: String,
ok: bool,
detail: String,
+ running: bool,
+ #[serde(rename = "downloadBytes", skip_serializing_if = "Option::is_none")]
+ download_bytes: Option<u64>,
}
#[derive(Serialize)]
@@ -206,6 +217,10 @@ struct SavedModelApiKeys {
struct SavedModelSessions {
openai: Option<bool>,
anthropic: Option<bool>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ google: Option<bool>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ xai: Option<bool>,
}
#[derive(Serialize)]
@@ -302,6 +317,26 @@ fn report<R: tauri::Runtime>(
step: step.into(),
ok,
detail: detail.into(),
+ running: false,
+ download_bytes: None,
+ },
+ );
+}
+
+fn report_running<R: tauri::Runtime>(
+ app: &tauri::AppHandle<R>,
+ step: &str,
+ detail: impl Into<String>,
+ download_bytes: Option<u64>,
+) {
+ let _ = app.emit(
+ "setup:progress",
+ Progress {
+ step: step.into(),
+ ok: true,
+ detail: detail.into(),
+ running: true,
+ download_bytes,
},
);
}
@@ -432,14 +467,27 @@ async fn prepare_installation(
if let Some(problem) = stack::deployment_problem(&root) {
return Err(Problem::from(problem));
}
- report(
+ report_running(
&handle,
"dependencies",
- true,
"Preparing the app's dependencies.",
+ None,
);
preparation::install_dependencies_if_needed(&root, || {
- install::ensure_bun(&root, which_bun())
+ report_running(
+ &handle,
+ "dependencies",
+ "Preparing the local runtime.",
+ None,
+ );
+ let bun = install::ensure_bun(&root, which_bun())?;
+ report_running(
+ &handle,
+ "dependencies",
+ "Installing the app's packages.",
+ None,
+ );
+ Ok(bun)
})?;
report(
&handle,
@@ -447,6 +495,12 @@ async fn prepare_installation(
true,
"The app's dependencies are installed.",
);
+ report_running(
+ &handle,
+ "images",
+ "Checking which local software to download.",
+ None,
+ );
let settings = preparation::image_settings(&root, picked.as_ref())?;
let installed = picked
.as_ref()
@@ -463,20 +517,30 @@ async fn prepare_installation(
images.dedup();
for (index, image) in images.iter().enumerate() {
attempt.require_current()?;
- report(
- &handle,
- "images",
- true,
- format!(
- "Downloading local software ({}/{}).",
- index + 1,
- images.len()
- ),
+ let detail = format!(
+ "Downloading local software ({}/{}).",
+ index + 1,
+ images.len()
);
- pull_metrics::pull_image(&address, image, |metrics| {
- desktop_telemetry::pull_completed(&handle, metrics)
- })?;
+ report_running(&handle, "images", &detail, None);
+ pull_metrics::pull_image(
+ &address,
+ image,
+ |bytes| report_running(&handle, "images", &detail, Some(bytes)),
+ |metrics| desktop_telemetry::pull_completed(&handle, metrics),
+ )?;
}
+ report(
+ &handle,
+ "images",
+ true,
+ format!(
+ "Local software is downloaded ({}/{}).",
+ images.len(),
+ images.len()
+ ),
+ );
+ report_running(&handle, "installation", "Finishing installation.", None);
attempt.require_current()?;
preparation::complete(&root, harness.as_ref(), images, &address)?;
preparation::save_selected_root(
@@ -510,6 +574,7 @@ async fn prepare_installation(
/// Reported step by step rather than as one result, because these take minutes and a window with
/// nothing moving in it reads as a hang.
async fn engine_ready(app: &tauri::AppHandle) -> Result<engine::Address, Problem> {
+ report_running(app, "engine", "Checking the software OpenBot needs.", None);
let found = engine::detect();
desktop_telemetry::observe_engine(app, &found);
let root = stack::default_root();
@@ -567,11 +632,11 @@ async fn engine_ready(app: &tauri::AppHandle) -> Result<engine::Address, Problem
// On a blocking thread for the reason the deployment fetch is: a blocking HTTP client dropped
// inside an async context panics the worker instead of returning an error, and the window
// survives that with a step that never ends.
- report(
+ report_running(
app,
"install-engine",
- true,
"Looking for the software OpenBot runs on.",
+ None,
);
let telemetry_app = app.clone();
let installed = tauri::async_runtime::spawn_blocking(move || {
@@ -609,18 +674,26 @@ async fn engine_ready(app: &tauri::AppHandle) -> Result<engine::Address, Problem
// One at a time, and each only if the last one worked. Written as a loop over an array once,
// which ran all three before the first was checked: a failed `machine init` was still followed
// by `machine start`.
+ report_running(app, "create-machine", "Preparing the engine machine.", None);
let created = acquire::create_machine(4, 6144, 60);
report(app, "create-machine", created.ok, created.said.clone());
if !created.ok {
return Err(created.problem());
}
+ report_running(app, "start-machine", "Starting the engine machine.", None);
let started = acquire::start_machine();
report(app, "start-machine", started.ok, started.said.clone());
if !started.ok {
return Err(started.problem());
}
+ report_running(
+ app,
+ "health-gate",
+ "Waiting for the engine to answer.",
+ None,
+ );
let gate = acquire::health_gate(&acquire::address());
report(app, "health-gate", gate.ok, gate.said.clone());
if !gate.ok {
@@ -629,7 +702,7 @@ async fn engine_ready(app: &tauri::AppHandle) -> Result<engine::Address, Problem
let ready = engine::detect();
desktop_telemetry::observe_engine(app, &ready);
- ready
+ let address = ready
.address
.clone()
.filter(|_| ready.responding)
@@ -638,7 +711,9 @@ async fn engine_ready(app: &tauri::AppHandle) -> Result<engine::Address, Problem
"OpenBot set up the software it runs on, but it is still not answering. Try again.",
ready.detail,
)
- })
+ })?;
+ report(app, "engine", true, "The container engine is answering.");
+ Ok(address)
}
/// Called while holding startup so Quit cannot retire the service during its acquisition.
@@ -664,6 +739,7 @@ async fn deployment_ready<R: tauri::Runtime>(
app: &tauri::AppHandle<R>,
root: &Path,
) -> Result<(), Problem> {
+ report_running(app, "deployment", "Checking the OpenBot release.", None);
// Both release discovery and downloading use blocking HTTP. Keeping them in a blocking task
// avoids dropping reqwest's runtime inside this async context.
let target = root.to_path_buf();
@@ -671,7 +747,12 @@ async fn deployment_ready<R: tauri::Runtime>(
let version = tauri::async_runtime::spawn_blocking(move || {
let version = deployment_release::resolve_version(&target)?;
if deployment::needs_fetch(&target, &version) {
- report(&handle, "deployment", true, format!("fetching {version}"));
+ report_running(
+ &handle,
+ "deployment",
+ format!("Downloading OpenBot {version}."),
+ None,
+ );
deployment::fetch(&target, &version)?;
}
Ok::<_, String>(version)
@@ -759,6 +840,18 @@ impl ChosenModel {
let given = |value: Option<String>| value.unwrap_or_default().trim().to_string();
let saved = self.saved.unwrap_or(false);
match (self.provider.as_str(), self.login.as_str()) {
+ ("google" | "xai", "oauth") => {
+ let saved = openbot_desktop_lib::provider_oauth::read(root, &self.provider)
+ .map_err(Problem::plain)?;
+ let model = given(self.model);
+ if model.is_empty() { return Err("Choose a model for this provider.".into()); }
+ Ok(openbot_env::ModelCredential::ProviderOAuth {
+ provider: self.provider,
+ path: root.join(openbot_desktop_lib::provider_oauth::FILE).to_string_lossy().into_owned(),
+ proxy_token: saved.proxy_token,
+ model,
+ })
+ }
("openai", "api-key") => {
let api_key = if saved {
saved_secret(root, "OPENAI_API_KEY")?
@@ -937,6 +1030,148 @@ fn require_existing_encryption_key(
Ok(())
}
+fn require_existing_encryption_key_with_recovery(
+ root: &Path,
+ secrets: &stack::Secrets,
+ existing_postgres_volume: impl FnOnce() -> Result<bool, Problem>,
+ resettable_volume: impl FnOnce() -> Result<Option<String>, Problem>,
+) -> Result<(), Problem> {
+ let mut volume_exists = false;
+ require_existing_encryption_key(root, secrets, || {
+ volume_exists = existing_postgres_volume()?;
+ Ok(volume_exists)
+ })
+ .map_err(|mut problem| {
+ // A failed probe is not proof of an existing volume. Configured roots never reach here.
+ if volume_exists {
+ let recovery = fresh_root_without_encryption_key(root, secrets).and_then(|fresh| {
+ if fresh {
+ resettable_volume()
+ } else {
+ Ok(None)
+ }
+ });
+ match recovery {
+ Ok(volume) => {
+ if volume.is_some() {
+ problem.said = "OpenBot found a database from a previous installation, but its encryption key is unavailable. Restore the original key to keep its saved data, or reset the leftover database to start fresh.".into();
+ }
+ problem.database_reset = volume;
+ }
+ Err(verification) => {
+ problem.detail = Some(match verification.detail {
+ Some(detail) => format!("{}\n{detail}", verification.said),
+ None => verification.said,
+ });
+ }
+ }
+ }
+ problem
+ })
+}
+
+/// Destructive recovery needs positive evidence that root metadata is readable and unconfigured.
+/// The ordinary startup guard keeps its existing behavior when metadata is unknown.
+fn fresh_root_without_encryption_key(
+ root: &Path,
+ secrets: &stack::Secrets,
+) -> Result<bool, Problem> {
+ if secrets
+ .get("KEY_ENCRYPTION_KEY")
+ .is_some_and(|key| openbot_env::usable_encryption_key(key))
+ {
+ return Ok(false);
+ }
+ let unknown = || {
+ Problem::plain("OpenBot could not verify that this is an unconfigured installation. Its leftover database cannot be reset here.")
+ };
+ let settings = openbot_env::read_already_set(&root.join(".env"), &["DATABASE_URL"])
+ .map_err(|_| unknown())?;
+ if settings.contains_key("DATABASE_URL") {
+ return Ok(false);
+ }
+ use openbot_desktop_lib::saved_intent::{SavedIntent, FILE};
+ match std::fs::read(root.join(FILE)) {
+ Ok(bytes) => {
+ let record: serde_json::Value =
+ serde_json::from_slice(&bytes).map_err(|_| unknown())?;
+ if record["version"].as_u64() != Some(1) {
+ return Err(unknown());
+ }
+ let intent: SavedIntent = serde_json::from_value(record).map_err(|_| unknown())?;
+ Ok(intent.model.is_none())
+ }
+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(true),
+ Err(_) => Err(unknown()),
+ }
+}
+
+fn reset_leftover_database_with(
+ shell: &Shell,
+ root: &Path,
+ volume: &str,
+ confirmed: bool,
+ read_secrets: impl FnOnce() -> Result<stack::Secrets, Problem>,
+ reset: impl FnOnce(&engine::Address, &stack::Secrets) -> Result<(), Problem>,
+) -> Result<(), Problem> {
+ if !confirmed {
+ return Err(Problem::plain("Confirm that you want to permanently delete the leftover database before resetting it."));
+ }
+ let attempt = StartAttempt::begin(shell)?;
+ let _startup = attempt.lock_current()?;
+ if shell.containers.lock().unwrap().is_some()
+ || shell.root.lock().unwrap().is_some()
+ || !shell.children.lock().unwrap().is_empty()
+ {
+ return Err(Problem::plain("OpenBot still owns running services. Choose Stop OpenBot before resetting a leftover database."));
+ }
+ if shell
+ .selected_root
+ .lock()
+ .unwrap()
+ .as_ref()
+ .is_some_and(|selected| selected != root)
+ {
+ return Err(Problem::plain("The selected installation changed. Try Start again before resetting its leftover database."));
+ }
+ let address = shell.leftover_database.lock().unwrap().as_ref()
+ .filter(|offer| offer.root == root && offer.volume == volume)
+ .map(|offer| offer.address.clone())
+ .ok_or_else(|| Problem::plain("The leftover database reset offer is no longer current. Try Start again before confirming a reset."))?;
+ let secrets = read_secrets()?;
+ if !fresh_root_without_encryption_key(root, &secrets)? {
+ return Err(Problem::plain("This installation is already configured or has its original encryption key. Its database cannot be reset here."));
+ }
+ reset(&address, &secrets)?;
+ *shell.leftover_database.lock().unwrap() = None;
+ Ok(())
+}
+
+#[tauri::command]
+async fn reset_leftover_database<R: tauri::Runtime>(
+ root: String,
+ volume: String,
+ confirmed: bool,
+ app: tauri::AppHandle<R>,
+) -> Result<(), Problem> {
+ let root = stack::root_from(&root);
+ let shell = app.state::<Shell>();
+ reset_leftover_database_with(
+ &shell,
+ &root,
+ &volume,
+ confirmed,
+ || {
+ openbot_desktop_lib::vault::already_given_no_ui(
+ &root,
+ &root.join(".env"),
+ &openbot_env::MINTED[..],
+ )
+ },
+ |address, secrets| stack::reset_leftover_database(address, &root, secrets, &volume),
+ )
+}
+
/// Write the `.env`, raise the containers, migrate, then start the three host processes.
#[tauri::command]
#[allow(
@@ -1015,6 +1250,7 @@ async fn start_stack_inner<R: tauri::Runtime>(
}
// A rejected concurrent Start must not replace the accepted attempt's selection.
remember_selected_root(&shell, &root);
+ *shell.leftover_database.lock().unwrap() = None;
}
/*
* Resolved from the catalogue rather than taken from the window.
@@ -1071,7 +1307,7 @@ async fn start_stack_inner<R: tauri::Runtime>(
)
})?;
- let (logs, bun, mut secrets) = {
+ let (logs, bun, mut secrets, ports) = {
let _startup = attempt.lock_current()?;
// Belt and braces: a fetch that reported success and left something out is still not a
@@ -1117,9 +1353,47 @@ async fn start_stack_inner<R: tauri::Runtime>(
&root.join(".env"),
&openbot_env::MINTED[..],
)?;
- require_existing_encryption_key(&root, &existing_secrets, || {
- stack::postgres_volume_exists(&found, &root, &existing_secrets)
+ require_existing_encryption_key_with_recovery(
+ &root,
+ &existing_secrets,
+ || stack::postgres_volume_exists(&found, &root, &existing_secrets),
+ || stack::leftover_database_volume(&found, &root, &existing_secrets),
+ )
+ .inspect_err(|problem| {
+ *shell.leftover_database.lock().unwrap() =
+ problem
+ .database_reset
+ .as_ref()
+ .map(|volume| LeftoverDatabase {
+ root: root.clone(),
+ volume: volume.clone(),
+ address: found.clone(),
+ });
+ })?;
+
+ // Only this deployment's recorded hosts are reclaimed; its existing containers are reusable.
+ let previous_ports = openbot_env::Ports::read(&root).map_err(|error| {
+ Problem::with("OpenBot could not read its local ports.", error.to_string())
})?;
+ let reclaimed = cleanup_before_start(&app, &attempt, &root, stack::stop_processes_under)?;
+ if reclaimed > 0 {
+ stack::wait_for_ports_to_clear(
+ &[previous_ports.server, previous_ports.app],
+ std::time::Duration::from_secs(5),
+ );
+ }
+ let ours = stack::ports_we_already_publish(&found, &root);
+ let ports = previous_ports
+ .available(
+ &ours,
+ picked.as_ref().and_then(|picked| picked.installed_port()),
+ )
+ .map_err(|error| {
+ Problem::with(
+ "OpenBot could not find available local ports. Try Start again.",
+ error.to_string(),
+ )
+ })?;
let mut settings = openbot_env::compose(
&openbot_env::Intelligence {
@@ -1131,7 +1405,7 @@ async fn start_stack_inner<R: tauri::Runtime>(
credential: credential.clone(),
},
&status,
- &openbot_env::Ports::default(),
+ &ports,
&deployment::image_variables(&root)?,
picked.as_ref(),
// What a previous start of this deployment already minted. Without it every Start writes a
@@ -1173,38 +1447,19 @@ async fn start_stack_inner<R: tauri::Runtime>(
&credential,
)?;
report(&app, "env", true, "settings written, credentials stored");
+ // Compose gives inherited environment precedence over .env. Pin this run's chosen ports.
+ secrets.extend(ports.settings());
+ for key in ["PICKED_HARNESS_PORT", "OPENBOT_TOOL_URL"] {
+ if let Some(value) = settings.get(key) {
+ secrets.insert(key.into(), value.clone());
+ }
+ }
// Set before Bun imports the runtime, and retained for supervised restarts.
secrets.extend(desktop_telemetry::runtime_env(&app));
// Installation already verified these images. Start only raises the local containers;
// its no-pull policy sends missing assets back to the installation step.
- report(&app, "services", true, "starting installed containers");
- /*
- * The harness's port, before the containers rather than after.
- *
- * The check below covers the host processes, and it runs too late for this: a port already held
- * makes `compose up` fail inside the daemon, and what reaches the person is
- * "Bind for 0.0.0.0:4202 failed: port is already allocated". Every harness has a fixed port of
- * its own, so this is not a rare case — anything else using it, including a previous run's
- * container, produces that sentence.
- */
- /*
- * Our own containers are not somebody else on the port.
- *
- * A start that failed after the containers went up left them running, and the next press of
- * Start refused because of them, naming a port the person never chose and cannot find. See
- * `ports_we_already_publish`. `compose up` reuses what is already there, so the only thing this
- * check is for is a stranger on the port.
- */
- let ours = stack::ports_we_already_publish(&found, &root);
- if let Some(port) = picked.as_ref().and_then(|picked| picked.installed_port()) {
- if let Some(problem) =
- stack::port_already_taken_except(&[("Bot you picked", port)], &ours)
- {
- report(&app, "ports", false, problem.clone());
- return Err(problem.into());
- }
- }
+ report_running(&app, "services", "starting installed containers", None);
// Only an installed harness needs the local service; a BYO endpoint is already running elsewhere.
let installed_harness = picked
@@ -1229,7 +1484,7 @@ async fn start_stack_inner<R: tauri::Runtime>(
stack::up(&found, &root, installed_harness, bundled_bots, &secrets)?;
report(&app, "services", true, "containers up");
- report(&app, "migrate", true, "applying migrations");
+ report_running(&app, "migrate", "applying migrations", None);
stack::migrate(&found, &root, &secrets)?;
report(&app, "migrate", true, "migrations applied");
@@ -1240,27 +1495,7 @@ async fn start_stack_inner<R: tauri::Runtime>(
report(&app, "services", false, detail);
})?;
- /*
- * Reclaim this deployment's own host processes before deciding the ports are taken.
- *
- * Same failure as the containers above, by a different route: a start that got as far as
- * spawning the server and then stopped left it running, and the next attempt refused because
- * port 3001 was held. By its own server. These are found by working directory, so anything this
- * stops belongs to this deployment and to no other.
- */
- let reclaimed = cleanup_before_start(&app, &attempt, &root, stack::stop_processes_under)?;
-
// Before spawning: if these are still held, whatever answers later is not ours.
- let ports = openbot_env::Ports::default();
- if reclaimed > 0 {
- // A kill is not instant and the check is. Without this the socket of a process this run
- // just stopped reads as somebody else's, and the refusal names a process that no longer
- // exists. See `wait_for_ports_to_clear`.
- stack::wait_for_ports_to_clear(
- &[ports.server, ports.app],
- std::time::Duration::from_secs(5),
- );
- }
if let Some(problem) =
stack::port_already_taken(&[("API server", ports.server), ("app", ports.app)])
{
@@ -1269,7 +1504,7 @@ async fn start_stack_inner<R: tauri::Runtime>(
}
let logs = root.join(".logs");
- (logs, bun, secrets)
+ (logs, bun, secrets, ports)
};
// Never persisted or passed to Compose. Only the server process receives this credential;
@@ -1292,15 +1527,15 @@ async fn start_stack_inner<R: tauri::Runtime>(
started,
&logs_for_wait,
&stack::Ready {
- api: openbot_env::Ports::default().server,
- app: openbot_env::Ports::default().app,
+ api: ports.server,
+ app: ports.app,
},
std::time::Duration::from_secs(180),
)
},
)
.await
- .inspect_err(|problem| report(&app, "answering", false, problem_detail(problem.clone())))?;
+ .inspect_err(|problem| report(&app, "answering", false, problem.said.clone()))?;
// Stop must not finish between accepting readiness and reporting a successful Start.
let _startup = attempt.lock_current()?;
// Only a stack that answered successfully acquires a restart policy.
@@ -1312,7 +1547,7 @@ async fn start_stack_inner<R: tauri::Runtime>(
.map(|owned| owned.address.clone())
.ok_or_else(|| Problem::plain("The local container runtime is unavailable."))?;
let config = host_access::HostAccessConfig::new(
- format!("http://127.0.0.1:{}", openbot_env::Ports::default().server),
+ format!("http://127.0.0.1:{}", ports.server),
host_token,
address,
deployment::reference(&root, "agent-computer")?,
@@ -1332,7 +1567,7 @@ async fn start_stack_inner<R: tauri::Runtime>(
)
})?;
preparation::save_selected_root(&config, &root)?;
- supervise_host_processes(app.clone(), root, logs, bun, secrets, generation);
+ supervise_host_processes(app.clone(), root, logs, bun, secrets, generation, ports);
report(&app, "answering", true, "the API and the app are answering");
Ok(())
@@ -1680,7 +1915,16 @@ where
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner),
);
- finish_host_start(attempt, root, started, outcome)
+ let readiness_failure = outcome.as_ref().err().cloned();
+ finish_host_start(attempt, root, started, outcome).map_err(|problem| {
+ // Preserve cancellation and lifecycle failures. Only the actual readiness error gets
+ // the startup headline; cleanup details remain attached and are redacted with it.
+ if readiness_failure.as_deref() == Some(problem.said.as_str()) {
+ stack::startup_problem(problem, secrets)
+ } else {
+ problem
+ }
+ })
}
fn finish_host_start(
@@ -2090,12 +2334,22 @@ where
#[tauri::command]
async fn show_openbot<R: tauri::Runtime>(app: tauri::AppHandle<R>) -> Result<(), Problem> {
tauri::async_runtime::spawn_blocking(move || {
- show_openbot_on(app, &openbot_env::Ports::default())
+ let ports = ports_for_shell(&app)?;
+ show_openbot_on(app, &ports)
})
.await
.map_err(|error| Problem::with("OpenBot could not open its window.", error.to_string()))?
}
+fn ports_for_shell<R: tauri::Runtime>(
+ app: &tauri::AppHandle<R>,
+) -> Result<openbot_env::Ports, Problem> {
+ let root = cleanup_root(&app.state::<Shell>(), &stack::default_root());
+ openbot_env::Ports::read(&root).map_err(|error| {
+ Problem::with("OpenBot could not read its local ports.", error.to_string())
+ })
+}
+
fn show_openbot_on<R: tauri::Runtime>(
app: tauri::AppHandle<R>,
ports: &openbot_env::Ports,
@@ -2307,7 +2561,7 @@ fn already_running<R: tauri::Runtime>(app: tauri::AppHandle<R>, root: String) ->
let shell = app.state::<Shell>();
let _startup = shell.startup.lock().unwrap();
!recovery_required_or_pending_quit_notice(&shell, &root)
- && already_running_at(&root, &openbot_env::Ports::default())
+ && openbot_env::Ports::read(&root).is_ok_and(|ports| already_running_at(&root, &ports))
}
fn already_running_at(root: &Path, ports: &openbot_env::Ports) -> bool {
@@ -2581,6 +2835,8 @@ fn already_configured_for_root(root: String) -> AlreadyConfigured {
openbot_env::saved_chatgpt_plan_store(&root),
),
anthropic: hint(Category::ClaudePlan, claude_plan),
+ google: hint(Category::GoogleOauth, false),
+ xai: hint(Category::XaiOauth, false),
},
model: intent.model,
},
@@ -2758,6 +3014,26 @@ async fn finish_intelligence_sign_in(
Ok(projects)
}
+/// Create a project using the account already signed in, without exposing its credential to the UI.
+#[tauri::command]
+async fn create_intelligence_project(
+ app: tauri::AppHandle,
+ name: String,
+) -> Result<openbot_desktop_lib::intelligence::Project, Problem> {
+ let credential = app
+ .state::<Shell>()
+ .intelligence_credential
+ .lock()
+ .unwrap()
+ .clone()
+ .ok_or_else(|| Problem::plain("Sign in to CopilotKit first."))?;
+ tauri::async_runtime::spawn_blocking(move || {
+ openbot_desktop_lib::intelligence::create_project(&credential, &name)
+ })
+ .await
+ .map_err(|error| Problem::with("Your project could not be created.", error.to_string()))?
+}
+
/// Create a key for the project somebody chose, and hand it back for the field.
#[tauri::command]
async fn intelligence_key_for(
@@ -2859,6 +3135,32 @@ fn providers() -> Vec<provider::Provider> {
provider::catalogue()
}
+#[tauri::command]
+async fn begin_model_oauth(
+ root: String,
+ provider: String,
+) -> Result<openbot_desktop_lib::provider_oauth::Authorization, String> {
+ tauri::async_runtime::spawn_blocking(move || {
+ openbot_desktop_lib::provider_oauth::begin(&stack::root_from(&root), &provider)
+ })
+ .await
+ .map_err(|e| e.to_string())?
+}
+
+#[tauri::command]
+async fn finish_model_oauth(attempt_id: String) -> Result<(), String> {
+ tauri::async_runtime::spawn_blocking(move || {
+ openbot_desktop_lib::provider_oauth::finish(&attempt_id)
+ })
+ .await
+ .map_err(|e| e.to_string())?
+}
+
+#[tauri::command]
+fn cancel_model_oauth(attempt_id: String) {
+ openbot_desktop_lib::provider_oauth::cancel(&attempt_id);
+}
+
/// `bun` from PATH, or the places an installer puts it when PATH has not been reloaded.
fn which_bun() -> Option<PathBuf> {
if quiet::command("bun")
@@ -2919,6 +3221,10 @@ fn publish_connection_failure<R: tauri::Runtime>(
Ok(true)
}
+#[allow(
+ clippy::too_many_arguments,
+ reason = "Retain selected ports alongside the supervised run's identity and credentials."
+)]
fn supervise_host_processes<R: tauri::Runtime>(
app: tauri::AppHandle<R>,
root: PathBuf,
@@ -2928,6 +3234,7 @@ fn supervise_host_processes<R: tauri::Runtime>(
// already wrong, and a credential prompt at that moment is the worst time to ask for one.
secrets: stack::Secrets,
generation: u64,
+ ports: openbot_env::Ports,
) -> std::thread::JoinHandle<()> {
std::thread::spawn(move || {
eprintln!(
@@ -2964,11 +3271,7 @@ fn supervise_host_processes<R: tauri::Runtime>(
&connection_client,
secrets.get("OPENBOT_DESKTOP_HOST_TOKEN"),
) {
- match desktop_connection::poll(
- client,
- openbot_env::Ports::default().server,
- token,
- ) {
+ match desktop_connection::poll(client, ports.server, token) {
Ok(Some(connection)) => {
match publish_connection_failure(&app, &root, generation, connection) {
Ok(published) => connection_notice_sent = published,
@@ -3126,7 +3429,15 @@ where
/// Used by the tray and by a second launch, both of which happen at moments when the caller has no
/// idea which of the two the person should be looking at.
fn show_whichever_applies(app: &tauri::AppHandle) {
- restore_window_on(app, &openbot_env::Ports::default());
+ match ports_for_shell(app) {
+ Ok(ports) => restore_window_on(app, &ports),
+ Err(problem) => {
+ *app.state::<Shell>().last_failure.lock().unwrap() = Some(problem);
+ if let Err(error) = show_setup_and_focus(app.clone()) {
+ eprintln!("{error}");
+ }
+ }
+ }
}
fn restore_window_on<R: tauri::Runtime>(app: &tauri::AppHandle<R>, ports: &openbot_env::Ports) {
@@ -3277,6 +3588,7 @@ fn main() {
prepare_engine,
prepare_installation,
start_stack,
+ reset_leftover_database,
stop_stack,
show_openbot,
show_setup,
@@ -3290,10 +3602,14 @@ fn main() {
begin_claude_sign_in,
finish_claude_sign_in,
begin_chatgpt_sign_in,
+ begin_model_oauth,
+ finish_model_oauth,
+ cancel_model_oauth,
finish_chatgpt_sign_in,
begin_intelligence_sign_in,
finish_intelligence_sign_in,
intelligence_key_for,
+ create_intelligence_project,
begin_organization_sign_in,
finish_organization_sign_in,
cancel_organization_sign_in,
@@ -4281,6 +4597,41 @@ mod tests {
std::fs::remove_dir_all(root).unwrap();
}
+ #[test]
+ fn oauth_start_reads_private_session_without_contacting_unstarted_proxy() {
+ let root = temp_root("oauth-start");
+ std::fs::create_dir_all(root.join(".openbot")).unwrap();
+ for provider in ["google", "xai"] {
+ let path = root.join(openbot_desktop_lib::provider_oauth::FILE);
+ let record = serde_json::json!({"version":1,"sessionId":"synthetic-session","provider":provider,"clientId":"synthetic-client","accessToken":"synthetic-access","refreshToken":"synthetic-refresh","expiresAt":1,"scope":"synthetic","proxyToken":"synthetic-proxy"});
+ std::fs::write(&path, serde_json::to_vec(&record).unwrap()).unwrap();
+ let choice = ChosenModel {
+ provider: provider.into(),
+ login: "oauth".into(),
+ api_key: None,
+ base_url: None,
+ container_base_url: None,
+ model: Some("chosen-model".into()),
+ token: None,
+ saved: Some(true),
+ };
+ let credential = start_stack_credential_with(&root, choice, |_, _| {
+ panic!("OAuth must not resolve an API key")
+ })
+ .unwrap();
+ assert_eq!(
+ credential,
+ openbot_env::ModelCredential::ProviderOAuth {
+ provider: provider.into(),
+ path: path.to_string_lossy().into_owned(),
+ proxy_token: "synthetic-proxy".into(),
+ model: "chosen-model".into()
+ }
+ );
+ }
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
#[test]
fn start_and_ask_resolve_saved_secrets_from_the_selected_root() {
let root_a = temp_root("selected-saved-root-a");
@@ -4481,14 +4832,294 @@ mod tests {
std::fs::remove_dir_all(root).unwrap();
}
+ #[test]
+ fn leftover_database_recovery_is_offered_only_for_a_proven_fresh_root() {
+ let root = temp_root("leftover-database-offer");
+ std::fs::create_dir_all(&root).unwrap();
+ let error = require_existing_encryption_key_with_recovery(
+ &root,
+ &stack::Secrets::new(),
+ || Ok(true),
+ || Ok(Some("openbot_postgres-data".into())),
+ )
+ .unwrap_err();
+ assert_eq!(
+ serde_json::to_value(error).unwrap()["database_reset"],
+ "openbot_postgres-data"
+ );
+ for (file, content) in [
+ (".env", "DATABASE_URL=postgres://fixture\n"),
+ (
+ openbot_desktop_lib::saved_intent::FILE,
+ r#"{"version":1,"categories":[],"model":"open-ai-api-key"}"#,
+ ),
+ (
+ openbot_desktop_lib::saved_intent::FILE,
+ "invalid-settings-secret",
+ ),
+ (
+ openbot_desktop_lib::saved_intent::FILE,
+ r#"{"version":99,"categories":[],"model":null}"#,
+ ),
+ ] {
+ std::fs::write(root.join(file), content).unwrap();
+ let error = require_existing_encryption_key_with_recovery(
+ &root,
+ &stack::Secrets::new(),
+ || Ok(true),
+ || panic!("unknown or configured roots must not offer deletion"),
+ )
+ .unwrap_err();
+ assert!(serde_json::to_value(error)
+ .unwrap()
+ .get("database_reset")
+ .is_none());
+ std::fs::remove_file(root.join(file)).unwrap();
+ }
+ let secrets = stack::Secrets::from([(
+ "KEY_ENCRYPTION_KEY".into(),
+ "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=".into(),
+ )]);
+ assert!(require_existing_encryption_key_with_recovery(
+ &root,
+ &secrets,
+ || panic!("original key needs no probe"),
+ || panic!("original key needs no reset")
+ )
+ .is_ok());
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
+ #[test]
+ fn leftover_database_reset_rechecks_confirmation_configuration_key_and_ownership() {
+ let root = temp_root("leftover-database-command");
+ std::fs::create_dir_all(&root).unwrap();
+ let shell = Shell::default();
+ let offer = || {
+ *shell.leftover_database.lock().unwrap() = Some(LeftoverDatabase {
+ root: root.clone(),
+ volume: "openbot_postgres-data".into(),
+ address: engine::Address::new(
+ engine::Engine::Podman,
+ Some("original-machine".into()),
+ ),
+ });
+ };
+ offer();
+ assert!(reset_leftover_database_with(
+ &shell,
+ &root,
+ "openbot_postgres-data",
+ false,
+ || panic!("unconfirmed must not access credentials"),
+ |_, _| panic!("unconfirmed must not delete")
+ )
+ .is_err());
+ assert!(reset_leftover_database_with(
+ &shell,
+ &root,
+ "openbot_postgres-data",
+ true,
+ || Ok(stack::Secrets::new()),
+ |_, _| Ok(())
+ )
+ .is_ok());
+ offer();
+ for (file, content) in [
+ (".env", "DATABASE_URL=postgres://fixture\n"),
+ (
+ openbot_desktop_lib::saved_intent::FILE,
+ r#"{"version":1,"categories":[],"model":"open-ai-api-key"}"#,
+ ),
+ (
+ openbot_desktop_lib::saved_intent::FILE,
+ "invalid-settings-secret",
+ ),
+ ] {
+ std::fs::write(root.join(file), content).unwrap();
+ assert!(reset_leftover_database_with(
+ &shell,
+ &root,
+ "openbot_postgres-data",
+ true,
+ || Ok(stack::Secrets::new()),
+ |_, _| panic!("configured or unknown root must not delete")
+ )
+ .is_err());
+ std::fs::remove_file(root.join(file)).unwrap();
+ }
+ std::fs::create_dir(root.join(".env")).unwrap();
+ assert!(reset_leftover_database_with(
+ &shell,
+ &root,
+ "openbot_postgres-data",
+ true,
+ || Ok(stack::Secrets::new()),
+ |_, _| panic!("unreadable settings must not delete")
+ )
+ .is_err());
+ std::fs::remove_dir(root.join(".env")).unwrap();
+ let secrets = stack::Secrets::from([(
+ "KEY_ENCRYPTION_KEY".into(),
+ "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=".into(),
+ )]);
+ assert!(reset_leftover_database_with(
+ &shell,
+ &root,
+ "openbot_postgres-data",
+ true,
+ || Ok(secrets),
+ |_, _| panic!("restored key must prevent deletion")
+ )
+ .is_err());
+ *shell.root.lock().unwrap() = Some(root.clone());
+ assert!(reset_leftover_database_with(
+ &shell,
+ &root,
+ "openbot_postgres-data",
+ true,
+ || panic!("owned hosts must refuse before credential access"),
+ |_, _| panic!("owned hosts must prevent deletion")
+ )
+ .is_err());
+ *shell.root.lock().unwrap() = None;
+ *shell.containers.lock().unwrap() = Some(ContainerDeployment {
+ root: root.clone(),
+ address: engine::Address::new(engine::Engine::Podman, Some("fixture".into())),
+ });
+ assert!(reset_leftover_database_with(
+ &shell,
+ &root,
+ "openbot_postgres-data",
+ true,
+ || panic!("owned containers must refuse"),
+ |_, _| panic!("owned containers must prevent deletion")
+ )
+ .is_err());
+ *shell.containers.lock().unwrap() = None;
+ let attempt = StartAttempt::begin(&shell).unwrap();
+ assert!(reset_leftover_database_with(
+ &shell,
+ &root,
+ "openbot_postgres-data",
+ true,
+ || panic!("concurrent startup must refuse"),
+ |_, _| panic!("concurrent startup must prevent deletion")
+ )
+ .is_err());
+ drop(attempt);
+ assert!(reset_leftover_database_with(
+ &shell,
+ &root,
+ "openbot_postgres-data",
+ true,
+ || Ok(stack::Secrets::new()),
+ |_, _| {
+ assert!(
+ shell.startup.try_lock().is_err(),
+ "deletion must retain the startup lock"
+ );
+ assert!(
+ StartAttempt::begin(&shell).is_err(),
+ "startup must remain excluded during deletion"
+ );
+ Ok(())
+ }
+ )
+ .is_ok());
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
+ #[test]
+ fn leftover_database_reset_keeps_offered_runtime_and_rejects_stale_offers() {
+ if crate::test_support::isolated_process(
+ "tests::leftover_database_reset_keeps_offered_runtime_and_rejects_stale_offers",
+ ) {
+ return;
+ }
+ let root = temp_root("leftover-database-affinity");
+ std::fs::create_dir_all(&root).unwrap();
+ let shell = Shell::default();
+ let original =
+ engine::Address::new(engine::Engine::Podman, Some("original-machine".into()));
+ let volume = "openbot_postgres-data";
+ assert!(reset_leftover_database_with(
+ &shell,
+ &root,
+ volume,
+ true,
+ || panic!("a missing offer must refuse before reading credentials"),
+ |_, _| panic!("a missing offer must not remove anything")
+ )
+ .is_err());
+ *shell.leftover_database.lock().unwrap() = Some(LeftoverDatabase {
+ root: root.clone(),
+ volume: volume.into(),
+ address: original.clone(),
+ });
+ for (selected_root, selected_volume) in [
+ (&root, "other-volume"),
+ (&root.join("another-root"), volume),
+ ] {
+ assert!(reset_leftover_database_with(
+ &shell,
+ selected_root,
+ selected_volume,
+ true,
+ || panic!("a mismatched offer must refuse before reading credentials"),
+ |_, _| panic!("a mismatched offer must not remove anything")
+ )
+ .is_err());
+ }
+ // Ambient choices may change while the confirmation is open. Both a new Docker endpoint
+ // and a new Podman default remain irrelevant to the already pinned offer.
+ std::env::set_var("DOCKER_HOST", "unix:///another-engine.sock");
+ std::env::set_var("CONTAINER_CONNECTION", "replacement-machine");
+ let unavailable = Problem::plain("the originally offered engine is unavailable");
+ assert_eq!(
+ reset_leftover_database_with(
+ &shell,
+ &root,
+ volume,
+ true,
+ || Ok(stack::Secrets::new()),
+ |address, _| {
+ assert_eq!(address, &original);
+ Err(unavailable.clone())
+ }
+ ),
+ Err(unavailable)
+ );
+ reset_leftover_database_with(
+ &shell,
+ &root,
+ volume,
+ true,
+ || Ok(stack::Secrets::new()),
+ |address, _| {
+ assert_eq!(address, &original);
+ let command = address.command();
+ let arguments: Vec<_> = command.get_args().collect();
+ assert_eq!(arguments, ["--connection", "original-machine"]);
+ Ok(())
+ },
+ )
+ .unwrap();
+ assert!(
+ shell.leftover_database.lock().unwrap().is_none(),
+ "successful reset consumes the offer"
+ );
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
/// Real engine boundary: all root metadata can disappear while a named volume survives.
- /// Creates only one uniquely named, empty test volume; never starts a container or database.
+ /// Owns one isolated project and empty database; never touches an existing deployment.
#[test]
- #[ignore = "creates and removes one isolated Docker volume"]
+ #[ignore = "creates an isolated database volume and starts Postgres on the explicitly selected engine"]
fn surviving_postgres_volume_blocks_fresh_root_without_key() {
let root = temp_root("encryption-key-volume-reinstall");
std::fs::create_dir_all(&root).unwrap();
- let volume = format!(
+ let project = format!(
"openbot-key-reinstall-fixture-{}-{}",
std::process::id(),
std::time::SystemTime::now()
@@ -4496,16 +5127,22 @@ mod tests {
.unwrap()
.as_nanos()
);
+ let volume = format!("{project}_postgres-data");
std::fs::write(
root.join("docker-compose.yml"),
format!(
- "services:\n postgres:\n image: pgvector/pgvector:pg17\n volumes:\n - database:/var/lib/postgresql/data\nvolumes:\n database:\n name: {volume}\n"
+ "name: {project}\nservices:\n postgres:\n image: docker.io/pgvector/pgvector:pg17\n environment:\n POSTGRES_PASSWORD: isolated-fixture-only\n volumes:\n - postgres-data:/var/lib/postgresql/data\n healthcheck:\n test: [CMD, pg_isready, -U, postgres]\n interval: 1s\n timeout: 5s\n retries: 45\nvolumes:\n postgres-data:\n"
),
)
.unwrap();
- let address = engine::Address::new(engine::Engine::Docker, None)
+ let selected = match std::env::var("OPENBOT_TEST_ENGINE").as_deref() {
+ Ok("podman") => engine::Engine::Podman,
+ Ok("docker") | Err(_) => engine::Engine::Docker,
+ Ok(other) => panic!("unknown explicit test engine: {other}"),
+ };
+ let address = engine::Address::new(selected, std::env::var("OPENBOT_TEST_CONNECTION").ok())
.pin()
- .expect("explicit selected Docker runtime");
+ .expect("explicit selected test runtime");
let created = address
.command()
.args([
@@ -4513,19 +5150,104 @@ mod tests {
"create",
"--label",
"ai.copilotkit.openbot.fixture=key-reinstall",
+ "--label",
+ &format!("com.docker.compose.project={project}"),
+ "--label",
+ "com.docker.compose.volume=postgres-data",
&volume,
])
.output()
.expect("create isolated volume");
assert!(created.status.success(), "fixture volume creation failed");
- let secrets = std::collections::BTreeMap::new();
- let guarded = require_existing_encryption_key(&root, &secrets, || {
- stack::postgres_volume_exists(&address, &root, &secrets)
+ // Always clean up this fixture, including when an assertion inside the workflow fails.
+ let workflow = std::panic::catch_unwind(|| {
+ let secrets = stack::Secrets::new();
+ let guarded = require_existing_encryption_key_with_recovery(
+ &root,
+ &secrets,
+ || stack::postgres_volume_exists(&address, &root, &secrets),
+ || stack::leftover_database_volume(&address, &root, &secrets),
+ )
+ .unwrap_err();
+ assert_eq!(guarded.database_reset.as_deref(), Some(volume.as_str()));
+ let shell = Shell::default();
+ *shell.leftover_database.lock().unwrap() = Some(LeftoverDatabase {
+ root: root.clone(),
+ volume: volume.clone(),
+ address: address.clone(),
+ });
+ assert!(reset_leftover_database_with(
+ &shell,
+ &root,
+ &volume,
+ false,
+ || Ok(secrets.clone()),
+ |address, secrets| stack::reset_leftover_database(address, &root, secrets, &volume)
+ )
+ .is_err());
+ assert!(stack::postgres_volume_exists(&address, &root, &secrets).unwrap());
+ assert!(!root.join(".secrets/KEY_ENCRYPTION_KEY.secret").exists());
+ assert!(!root.join(".env").exists());
+ reset_leftover_database_with(
+ &shell,
+ &root,
+ &volume,
+ true,
+ || Ok(secrets.clone()),
+ |address, secrets| stack::reset_leftover_database(address, &root, secrets, &volume),
+ )
+ .unwrap();
+ require_existing_encryption_key(&root, &secrets, || {
+ stack::postgres_volume_exists(&address, &root, &secrets)
+ })
+ .unwrap();
+ let started = address
+ .command()
+ .current_dir(&root)
+ .args([
+ "compose",
+ "up",
+ "--detach",
+ "--wait",
+ "--wait-timeout",
+ "60",
+ "postgres",
+ ])
+ .output()
+ .unwrap();
+ assert!(
+ started.status.success(),
+ "isolated Postgres must start after recovery: {}",
+ String::from_utf8_lossy(&started.stderr)
+ );
+ assert!(
+ stack::reset_leftover_database(&address, &root, &secrets, &volume).is_err(),
+ "the real engine must refuse an attached database volume"
+ );
+ let ready = address
+ .command()
+ .current_dir(&root)
+ .args([
+ "compose",
+ "exec",
+ "-T",
+ "postgres",
+ "pg_isready",
+ "-U",
+ "postgres",
+ ])
+ .output()
+ .unwrap();
+ assert!(
+ ready.status.success(),
+ "Postgres must remain ready after the refused attached-volume reset"
+ );
});
- let survived = address
+ let stopped = address
.command()
- .args(["volume", "inspect", &volume])
+ .current_dir(&root)
+ .args(["compose", "down"])
.output()
.unwrap();
let removed = address
@@ -4533,33 +5255,18 @@ mod tests {
.args(["volume", "rm", &volume])
.output()
.unwrap();
- let fresh = require_existing_encryption_key(&root, &secrets, || {
- stack::postgres_volume_exists(&address, &root, &secrets)
- });
- let key_was_not_written = !root.join(".secrets/KEY_ENCRYPTION_KEY.secret").exists();
- let settings_were_not_written = !root.join(".env").exists();
std::fs::remove_dir_all(&root).unwrap();
assert!(
- removed.status.success(),
- "remove only the fixture-owned volume"
- );
- assert!(
- survived.status.success(),
- "the guard must preserve the existing volume"
+ stopped.status.success(),
+ "stop only the isolated fixture project"
);
- assert!(key_was_not_written && settings_were_not_written);
assert!(
- guarded.is_err(),
- "a fresh root with a surviving Postgres volume must not mint a replacement key"
- );
- assert!(guarded
- .unwrap_err()
- .said
- .contains("Restore its original private key"));
- assert!(
- fresh.is_ok(),
- "the same root is fresh once its test-owned volume is absent"
+ removed.status.success(),
+ "remove only the fixture-owned volume"
);
+ if let Err(panic) = workflow {
+ std::panic::resume_unwind(panic);
+ }
}
#[test]
@@ -7616,6 +8323,7 @@ fn main() {
fixture.host.bun.clone(),
stack::Secrets::new(),
generation,
+ openbot_env::Ports::default(),
));
// The actual watcher exhausts its actual budget and backoffs after this role fails.
std::fs::write(fixture.host.root.join(failed_role).join("fail"), "").unwrap();
@@ -7814,6 +8522,7 @@ fn main() {
fixture.host.bun.clone(),
stack::Secrets::new(),
generation,
+ openbot_env::Ports::default(),
));
std::fs::write(fixture.host.root.join("worker/fail"), "").unwrap();
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(70);
@@ -7937,6 +8646,7 @@ fn main() {
fixture.host.bun.clone(),
stack::Secrets::new(),
generation,
+ openbot_env::Ports::default(),
));
let original = {
let mut children = shell.children.lock().unwrap();
@@ -8262,7 +8972,22 @@ fn main() {
"wait-panics" => "the wait did not run:",
_ => unreachable!(),
};
- assert!(problem.said.starts_with(expected), "{problem:?}");
+ if matches!(mode, "wait-fails" | "wait-panics") {
+ assert!(
+ problem.said.contains("could not finish starting"),
+ "{problem:?}"
+ );
+ assert!(
+ problem
+ .detail
+ .as_deref()
+ .unwrap_or_default()
+ .starts_with(expected),
+ "{problem:?}"
+ );
+ } else {
+ assert!(problem.said.starts_with(expected), "{problem:?}");
+ }
if mode == "cleanup-refuses" {
assert_eq!(alive.len(), 1);
assert_eq!(shell.children.lock().unwrap().len(), 1);
@@ -9290,6 +10015,40 @@ fn main() {
assert_eq!(window.url().unwrap().as_str(), current);
}
+ #[test]
+ fn reopening_uses_persisted_ports_and_still_requires_deployment_ownership() {
+ let f = RestoreFixture::new();
+ for root in [&f.owned, &f.selected] {
+ openbot_env::write(
+ &root.join(".env"),
+ &f.ports.settings(),
+ &std::collections::BTreeMap::new(),
+ )
+ .unwrap();
+ }
+ let app = f.app(&f.owned, "tauri://localhost/");
+ assert_eq!(ports_for_shell(app.handle()).unwrap(), f.ports);
+ assert!(already_running(
+ app.handle().clone(),
+ f.owned.to_string_lossy().into_owned()
+ ));
+ tauri::async_runtime::block_on(show_openbot(app.handle().clone())).unwrap();
+ assert_eq!(
+ app.get_webview_window("main")
+ .unwrap()
+ .url()
+ .unwrap()
+ .port(),
+ Some(f.ports.app)
+ );
+ let other = f.app(&f.selected, "tauri://localhost/");
+ assert!(!already_running(
+ other.handle().clone(),
+ f.selected.to_string_lossy().into_owned()
+ ));
+ assert!(tauri::async_runtime::block_on(show_openbot(other.handle().clone())).is_err());
+ }
+
#[test]
fn restore_window_refuses_answering_other_deployment_and_shows_recorded_setup() {
let f = RestoreFixture::new();
diff --git a/desktop/src-tauri/src/organization_auth.rs b/desktop/src-tauri/src/organization_auth.rs
index 60fa912c..e6eff80c 100644
--- a/desktop/src-tauri/src/organization_auth.rs
+++ b/desktop/src-tauri/src/organization_auth.rs
@@ -7,8 +7,8 @@ use reqwest::blocking::Client;
use reqwest::Url;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
-use std::io::{Read, Write};
-use std::net::TcpListener;
+use std::io::Write;
+use std::net::{TcpListener, TcpStream};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{mpsc, Arc, Mutex, OnceLock};
@@ -177,6 +177,23 @@ fn callback_code(request: &str, expected_state: &str) -> Result<String, Problem>
Ok(codes[0].1.to_string())
}
+fn receive_callback(stream: &mut TcpStream, expected_state: &str) -> Result<String, Problem> {
+ let result = crate::provider_oauth::read_callback_request(stream, Duration::from_secs(3))
+ .map_err(|_| problem("OpenBot could not read the organization callback."))
+ .and_then(|request| callback_code(&request, expected_state));
+ let (status, message) = if result.is_ok() {
+ ("200 OK", "Sign-in received. You can return to OpenBot.")
+ } else {
+ (
+ "400 Bad Request",
+ "Sign-in did not match. Return to OpenBot and try again.",
+ )
+ };
+ let reply = format!("HTTP/1.1 {status}\r\nContent-Type: text/plain; charset=utf-8\r\nCache-Control: no-store\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{message}", message.len());
+ let _ = stream.write_all(reply.as_bytes());
+ result
+}
+
pub fn begin(root: &Path, authority_url: &str, provider: &str) -> Result<String, Problem> {
let authority = authority(authority_url)?;
if !matches!(provider, "google" | "microsoft" | "okta") {
@@ -227,27 +244,7 @@ pub fn begin(root: &Path, authority_url: &str, provider: &str) -> Result<String,
while started.elapsed() < PATIENCE && !cancel_listener.load(Ordering::SeqCst) {
match listener.accept() {
Ok((mut stream, _)) => {
- let _ = stream.set_read_timeout(Some(Duration::from_secs(3)));
- let mut bytes = [0u8; 8192];
- let result = stream
- .read(&mut bytes)
- .map_err(|_| problem("OpenBot could not read the organization callback."))
- .and_then(|length| {
- callback_code(
- &String::from_utf8_lossy(&bytes[..length]),
- &expected_state,
- )
- });
- let (status, message) = if result.is_ok() {
- ("200 OK", "Sign-in received. You can return to OpenBot.")
- } else {
- (
- "400 Bad Request",
- "Sign-in did not match. Return to OpenBot and try again.",
- )
- };
- let reply = format!("HTTP/1.1 {status}\r\nContent-Type: text/plain; charset=utf-8\r\nCache-Control: no-store\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{message}", message.len());
- let _ = stream.write_all(reply.as_bytes());
+ let result = receive_callback(&mut stream, &expected_state);
let _ = sender.send(result);
return;
}
@@ -403,7 +400,74 @@ pub fn session_destination(
#[cfg(test)]
mod tests {
use super::*;
- use std::io::{BufRead, BufReader};
+ use std::io::{BufRead, BufReader, Read};
+ fn callback_over_tcp(nonblocking: bool, fragmented: bool) {
+ let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
+ listener.set_nonblocking(true).unwrap();
+ let mut browser = TcpStream::connect(listener.local_addr().unwrap()).unwrap();
+ browser
+ .set_read_timeout(Some(Duration::from_secs(3)))
+ .unwrap();
+ let deadline = Instant::now() + Duration::from_secs(2);
+ let (mut stream, _) = loop {
+ match listener.accept() {
+ Ok(accepted) => break accepted,
+ Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
+ assert!(
+ Instant::now() < deadline,
+ "browser connection was not accepted"
+ );
+ std::thread::yield_now();
+ }
+ Err(error) => panic!("browser connection failed: {error}"),
+ }
+ };
+ // Unix does not consistently inherit this flag; model the Windows accept behavior.
+ if nonblocking {
+ stream.set_nonblocking(true).unwrap();
+ } else {
+ stream.set_nonblocking(false).unwrap();
+ }
+ let request = b"GET /organization-auth/callback?state=expected&code=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa HTTP/1.1\r\nHost: localhost\r\n\r\n";
+ let split = if fragmented { 18 } else { 0 };
+ if fragmented {
+ browser.write_all(&request[..split]).unwrap();
+ }
+ let (sender, receiver) = std::sync::mpsc::channel();
+ let worker = std::thread::spawn(move || {
+ sender
+ .send(receive_callback(&mut stream, "expected"))
+ .unwrap();
+ });
+ let early = receiver.recv_timeout(Duration::from_millis(100));
+ if !matches!(early, Err(std::sync::mpsc::RecvTimeoutError::Timeout)) {
+ worker.join().unwrap();
+ panic!("callback completed before its request line arrived: {early:?}");
+ }
+ browser.write_all(&request[split..]).unwrap();
+ assert_eq!(
+ receiver
+ .recv_timeout(Duration::from_secs(3))
+ .unwrap()
+ .unwrap(),
+ "a".repeat(32)
+ );
+ let mut response = String::new();
+ browser.read_to_string(&mut response).unwrap();
+ assert!(response.starts_with("HTTP/1.1 200 OK\r\n"));
+ worker.join().unwrap();
+ }
+
+ #[test]
+ fn callback_waits_for_delayed_get_on_nonblocking_stream() {
+ callback_over_tcp(true, false);
+ }
+
+ #[test]
+ fn callback_waits_for_fragmented_request_line() {
+ callback_over_tcp(false, true);
+ }
+
#[test]
fn cancellation_retires_a_finish_already_waiting_for_the_browser() {
let root = PathBuf::from("organization-cancellation-fixture");
diff --git a/desktop/src-tauri/src/preparation.rs b/desktop/src-tauri/src/preparation.rs
index d7ca0bce..787d4ac5 100644
--- a/desktop/src-tauri/src/preparation.rs
+++ b/desktop/src-tauri/src/preparation.rs
@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
-use crate::{deployment, engine::Address, harness::HarnessChoice, problem::Problem, quiet, stack};
+use crate::{deployment, engine::Address, harness::HarnessChoice, problem::Problem, stack};
pub const REQUIRED: &str = "Finish installing OpenBot's local software before signing in or starting. Return to Install and try again.";
pub const FILE: &str = ".openbot-prepared.json";
@@ -228,15 +228,8 @@ pub fn dependencies_ready(root: &Path) -> Result<PathBuf, Problem> {
));
}
// This executes only the installed runtime's version probe; it cannot install packages.
- if !quiet::command(&record.bun)
- .arg("--version")
- .output()
- .map_err(|e| required(e.to_string()))?
- .status
- .success()
- {
- return Err(required("The installed app runtime is unavailable."));
- }
+ crate::install::verify_bun(&record.bun)
+ .map_err(|problem| required(problem.detail.unwrap_or(problem.said)))?;
Ok(record.bun)
}
@@ -383,7 +376,11 @@ mod tests {
use std::io::Write;
fn main() {
let args: Vec<String> = std::env::args().skip(1).collect();
- if args == ["--version"] { println!("1.3.14"); return; }
+ if args == ["--version"] {
+ let version = std::env::current_exe().unwrap().parent().unwrap().join("runtime-version");
+ println!("{}", std::fs::read_to_string(version).unwrap_or_else(|_| "1.3.14".into()));
+ return;
+ }
assert_eq!(args, ["install", "--frozen-lockfile", "--ignore-scripts"]);
let previous = std::fs::read_to_string("installs").unwrap_or_default();
writeln!(std::fs::OpenOptions::new().create(true).append(true).open("installs").unwrap(), "install").unwrap();
@@ -452,6 +449,19 @@ fn main() {
);
}
+ #[test]
+ fn cached_dependencies_with_unsupported_runtime_require_installation_before_start() {
+ let f = Fixture::new();
+ f.dependencies();
+ std::fs::write(f.root.join("runtime-version"), "1.2.15").unwrap();
+ let problem = dependencies_ready(&f.root).expect_err("a cached older runtime is not ready");
+ assert!(problem.said.contains("Finish installing"));
+ assert!(problem
+ .detail
+ .unwrap_or_default()
+ .contains(crate::install::BUN));
+ }
+
#[test]
fn failed_image_preparation_cannot_publish_completion() {
let f = Fixture::new();
diff --git a/desktop/src-tauri/src/problem.rs b/desktop/src-tauri/src/problem.rs
index 0329c3d4..285418fd 100644
--- a/desktop/src-tauri/src/problem.rs
+++ b/desktop/src-tauri/src/problem.rs
@@ -33,6 +33,9 @@ pub struct Problem {
/// The credential operation that failed, never inferred from provider log text.
#[serde(skip_serializing_if = "Option::is_none")]
pub connection: Option<Connection>,
+ /// The full, verified Compose volume name offered for an explicit fresh-install reset.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub database_reset: Option<String>,
}
impl Problem {
@@ -42,6 +45,7 @@ impl Problem {
said: said.into(),
detail: None,
connection: None,
+ database_reset: None,
}
}
@@ -52,6 +56,7 @@ impl Problem {
said: said.into(),
detail: (!detail.trim().is_empty()).then_some(detail),
connection: None,
+ database_reset: None,
}
}
diff --git a/desktop/src-tauri/src/provider.rs b/desktop/src-tauri/src/provider.rs
index 879da8c3..7a24ad2d 100644
--- a/desktop/src-tauri/src/provider.rs
+++ b/desktop/src-tauri/src/provider.rs
@@ -1,9 +1,7 @@
//! The model provider screen's list, as data.
//!
-//! Two providers are first-class and everything else is one row. That is not a shortlist waiting to
-//! be grown: it is the shape, and growing it is how this screen turns into a directory nobody
-//! maintains. Most people have a plan with one of two companies; everybody else has something that
-//! speaks the OpenAI wire format, because at this point everything does.
+//! OpenAI and Anthropic offer plan sign-in alongside API keys. Google and xAI use named endpoint
+//! presets with API keys; their official addresses are supplied by the frontend.
//!
//! The row that asks for a URL is the last one, and it is the only one that asks. Keeping it there
//! is what keeps a base URL off the main path, which the audience rule at the top of the build doc
@@ -24,6 +22,8 @@ pub enum Login {
ApiKey,
/// A base URL, a key and a model name. The developer row and the everything-else row at once.
Endpoint,
+ /// Browser authorization for the provider's model API, with renewable credentials.
+ Oauth,
}
/// One row on the model screen.
@@ -88,10 +88,26 @@ pub fn catalogue() -> Vec<Provider> {
.into(),
}),
},
+ Provider {
+ id: "google".into(),
+ name: "Google Gemini".into(),
+ summary: "Use a Google AI Studio key or sign in for Gemini API access.".into(),
+ logins: vec![Login::Endpoint, Login::Oauth],
+ mark: None,
+ caution: None,
+ },
+ Provider {
+ id: "xai".into(),
+ name: "xAI".into(),
+ summary: "Use an xAI API key or sign in to your xAI account.".into(),
+ logins: vec![Login::Endpoint, Login::Oauth],
+ mark: None,
+ caution: None,
+ },
Provider {
id: "openai-compatible".into(),
name: "Any OpenAI-compatible endpoint".into(),
- summary: "Azure, Bedrock, Mistral, DeepSeek, xAI, Ollama, vLLM or your own.".into(),
+ summary: "Azure, Bedrock, Mistral, DeepSeek, Ollama, vLLM or your own.".into(),
logins: vec![Login::Endpoint],
// Deliberately unmarked: it stands for every provider rather than one, so any single
// vendor's logo here would be a lie about what the row does.
@@ -105,16 +121,21 @@ pub fn catalogue() -> Vec<Provider> {
mod tests {
use super::*;
- /// The audience rule, as a test. A base URL is a developer's tool, and exactly one row may ask
- /// for one; if a second ever does, the main path has grown a terminal-shaped step.
+ /// Named endpoint presets use API keys and never claim support for a subscription sign-in.
#[test]
- fn only_one_row_asks_for_a_url() {
+ fn endpoint_providers_do_not_offer_plan_sign_in() {
let asking: Vec<String> = catalogue()
.into_iter()
.filter(|p| p.logins.contains(&Login::Endpoint))
.map(|p| p.id)
.collect();
- assert_eq!(asking, vec!["openai-compatible".to_string()]);
+ assert_eq!(asking, vec!["google", "xai", "openai-compatible"]);
+ for provider in catalogue()
+ .into_iter()
+ .filter(|provider| provider.logins.contains(&Login::Endpoint))
+ {
+ assert!(!provider.logins.contains(&Login::Plan));
+ }
}
/// Where a plan can stand in for a key, it is the default. Reordering these is a product change
@@ -133,14 +154,15 @@ mod tests {
}
}
- /// Two first-class providers and one escape hatch. Growing this list is how the screen becomes
- /// a directory, so it fails here rather than in review.
+ /// Named providers stay ahead of the custom endpoint escape hatch.
#[test]
- fn two_named_providers_and_one_way_in_for_everything_else() {
+ fn four_named_providers_and_one_custom_endpoint() {
let rows = catalogue();
- assert_eq!(rows.len(), 3, "the provider list grew");
- assert_eq!(rows[0].id, "openai");
- assert_eq!(rows[1].id, "anthropic");
+ let ids: Vec<&str> = rows.iter().map(|provider| provider.id.as_str()).collect();
+ assert_eq!(
+ ids,
+ vec!["openai", "anthropic", "google", "xai", "openai-compatible"]
+ );
}
/// Every row is readable without recognising a logo.
diff --git a/desktop/src-tauri/src/provider_oauth.rs b/desktop/src-tauri/src/provider_oauth.rs
new file mode 100644
index 00000000..a487f9bf
--- /dev/null
+++ b/desktop/src-tauri/src/provider_oauth.rs
@@ -0,0 +1,1010 @@
+//! Desktop provider authorization. Tokens stay in the installation's private runtime store.
+use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
+use rand::RngCore;
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::{
+ io::{Read, Write},
+ net::{TcpListener, TcpStream},
+ path::{Path, PathBuf},
+ sync::{
+ atomic::{AtomicBool, Ordering},
+ Arc, Mutex, OnceLock,
+ },
+ time::{Duration, Instant, SystemTime, UNIX_EPOCH},
+};
+
+#[path = "provider_oauth_lock.rs"]
+mod credential_lock;
+
+pub const FILE: &str = ".openbot/model-oauth.json";
+const XAI_CLIENT: &str = "b1a00492-073a-47ea-816f-4c329264a828";
+const XAI_SCOPE: &str = "openid profile email offline_access grok-cli:access api:access";
+const GOOGLE_SCOPE: &str = "https://www.googleapis.com/auth/cloud-platform https://www.googleapis.com/auth/generative-language.retriever";
+
+#[derive(Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Credentials {
+ pub version: u8,
+ pub session_id: String,
+ pub provider: String,
+ pub client_id: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub client_secret: Option<String>,
+ pub access_token: String,
+ pub refresh_token: String,
+ pub expires_at: u64,
+ pub scope: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub quota_project: Option<String>,
+ pub proxy_token: String,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Authorization {
+ pub attempt_id: String,
+ pub url: String,
+ pub user_code: Option<String>,
+}
+
+struct Flow {
+ id: String,
+ root: PathBuf,
+ canceled: AtomicBool,
+ pending: Mutex<Option<Pending>>,
+}
+enum Pending {
+ Google {
+ listener: TcpListener,
+ verifier: String,
+ state: String,
+ redirect: String,
+ client_id: String,
+ client_secret: Option<String>,
+ project: String,
+ },
+ Xai {
+ client_id: String,
+ device_code: String,
+ interval: u64,
+ expires: Instant,
+ },
+}
+static ACTIVE: OnceLock<Mutex<Option<Arc<Flow>>>> = OnceLock::new();
+fn active() -> &'static Mutex<Option<Arc<Flow>>> {
+ ACTIVE.get_or_init(|| Mutex::new(None))
+}
+fn random() -> String {
+ let mut bytes = [0; 32];
+ rand::rng().fill_bytes(&mut bytes);
+ URL_SAFE_NO_PAD.encode(bytes)
+}
+fn configured(name: &str) -> Option<String> {
+ let embedded = match name {
+ "OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_ID" => {
+ option_env!("OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_ID")
+ }
+ "OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_SECRET" => {
+ option_env!("OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_SECRET")
+ }
+ "OPENBOT_GOOGLE_MODEL_OAUTH_QUOTA_PROJECT" => {
+ option_env!("OPENBOT_GOOGLE_MODEL_OAUTH_QUOTA_PROJECT")
+ }
+ "OPENBOT_XAI_MODEL_OAUTH_CLIENT_ID" => option_env!("OPENBOT_XAI_MODEL_OAUTH_CLIENT_ID"),
+ _ => None,
+ };
+ std::env::var(name)
+ .ok()
+ .or_else(|| embedded.map(str::to_owned))
+ .map(|v| v.trim().to_owned())
+ .filter(|v| !v.is_empty())
+}
+fn http() -> Result<reqwest::blocking::Client, String> {
+ reqwest::blocking::Client::builder()
+ .timeout(Duration::from_secs(25))
+ .redirect(reqwest::redirect::Policy::none())
+ .user_agent("OpenBot/desktop-provider-oauth")
+ .build()
+ .map_err(|e| e.to_string())
+}
+fn response_json(response: reqwest::blocking::Response) -> Result<serde_json::Value, String> {
+ let status = response.status();
+ let value: serde_json::Value = response
+ .json()
+ .map_err(|_| "The provider returned an unreadable sign-in response.".to_string())?;
+ if !status.is_success() {
+ return Err(format!(
+ "Provider sign-in failed ({}): {}",
+ status.as_u16(),
+ value
+ .get("error_description")
+ .or_else(|| value.get("error"))
+ .and_then(|v| v.as_str())
+ .unwrap_or("request refused")
+ ));
+ }
+ Ok(value)
+}
+fn required(value: &serde_json::Value, field: &str) -> Result<String, String> {
+ value
+ .get(field)
+ .and_then(|v| v.as_str())
+ .filter(|v| !v.is_empty())
+ .map(str::to_owned)
+ .ok_or_else(|| format!("The provider omitted {field} from its sign-in response."))
+}
+fn reserve(root: &Path) -> Arc<Flow> {
+ let flow = Arc::new(Flow {
+ id: random(),
+ root: root.to_owned(),
+ canceled: AtomicBool::new(false),
+ pending: Mutex::new(None),
+ });
+ if let Some(previous) = active().lock().unwrap().replace(flow.clone()) {
+ previous.canceled.store(true, Ordering::SeqCst);
+ }
+ flow
+}
+pub fn begin(root: &Path, provider: &str) -> Result<Authorization, String> {
+ // Reserve before blocking network work so a late response cannot replace a newer sign-in.
+ let flow = reserve(root);
+ let (pending, url, user_code) = match provider {
+ "google" => {
+ let client_id = configured("OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_ID").ok_or("Google sign-in needs this OpenBot build's registered desktop OAuth client. Use an API key until it is configured.")?;
+ let project = configured("OPENBOT_GOOGLE_MODEL_OAUTH_QUOTA_PROJECT").ok_or(
+ "Google sign-in needs a Google Cloud quota project with the Gemini API enabled.",
+ )?;
+ let client_secret = configured("OPENBOT_GOOGLE_MODEL_OAUTH_CLIENT_SECRET");
+ let listener = TcpListener::bind("127.0.0.1:0").map_err(|e| e.to_string())?;
+ listener.set_nonblocking(true).map_err(|e| e.to_string())?;
+ let redirect = format!(
+ "http://127.0.0.1:{}/oauth/callback",
+ listener.local_addr().map_err(|e| e.to_string())?.port()
+ );
+ let verifier = random();
+ let state = random();
+ let challenge = URL_SAFE_NO_PAD.encode(Sha256::digest(verifier.as_bytes()));
+ let mut url =
+ reqwest::Url::parse("https://accounts.google.com/o/oauth2/v2/auth").unwrap();
+ url.query_pairs_mut().extend_pairs([
+ ("client_id", client_id.as_str()),
+ ("redirect_uri", redirect.as_str()),
+ ("response_type", "code"),
+ ("scope", GOOGLE_SCOPE),
+ ("access_type", "offline"),
+ ("prompt", "consent"),
+ ("state", state.as_str()),
+ ("code_challenge", challenge.as_str()),
+ ("code_challenge_method", "S256"),
+ ]);
+ (
+ Pending::Google {
+ listener,
+ verifier,
+ state,
+ redirect,
+ client_id,
+ client_secret,
+ project,
+ },
+ url.to_string(),
+ None,
+ )
+ }
+ "xai" => {
+ let client_id = configured("OPENBOT_XAI_MODEL_OAUTH_CLIENT_ID")
+ .unwrap_or_else(|| XAI_CLIENT.into());
+ let body = response_json(
+ http()?
+ .post("https://auth.x.ai/oauth2/device/code")
+ .form(&[
+ ("client_id", client_id.as_str()),
+ ("scope", XAI_SCOPE),
+ ("referrer", "openbot"),
+ ])
+ .send()
+ .map_err(|e| e.to_string())?,
+ )?;
+ let url = xai_verification_url(&body)?;
+ let user_code = required(&body, "user_code")?;
+ let device_code = required(&body, "device_code")?;
+ let interval = body
+ .get("interval")
+ .and_then(|v| v.as_u64())
+ .unwrap_or(5)
+ .max(1);
+ let expires = Instant::now()
+ + Duration::from_secs(
+ body.get("expires_in")
+ .and_then(|v| v.as_u64())
+ .unwrap_or(600)
+ .min(1800),
+ );
+ (
+ Pending::Xai {
+ client_id,
+ device_code,
+ interval,
+ expires,
+ },
+ url,
+ Some(user_code),
+ )
+ }
+ _ => return Err("That provider does not support this sign-in flow.".into()),
+ };
+ check(&flow)?;
+ *flow.pending.lock().unwrap() = Some(pending);
+ Ok(Authorization {
+ attempt_id: flow.id.clone(),
+ url,
+ user_code,
+ })
+}
+
+pub fn cancel(id: &str) {
+ let mut current = active().lock().unwrap();
+ if current.as_ref().is_some_and(|flow| flow.id == id) {
+ if let Some(flow) = current.take() {
+ flow.canceled.store(true, Ordering::SeqCst);
+ }
+ }
+}
+fn check(flow: &Flow) -> Result<(), String> {
+ if flow.canceled.load(Ordering::SeqCst) {
+ Err("Sign-in was canceled.".into())
+ } else {
+ Ok(())
+ }
+}
+fn wait(flow: &Flow, duration: Duration) -> Result<(), String> {
+ let end = Instant::now() + duration;
+ while Instant::now() < end {
+ check(flow)?;
+ std::thread::sleep(
+ Duration::from_millis(100).min(end.saturating_duration_since(Instant::now())),
+ );
+ }
+ check(flow)
+}
+
+fn xai_verification_url(body: &serde_json::Value) -> Result<String, String> {
+ let value = body
+ .get("verification_uri_complete")
+ .and_then(|v| v.as_str())
+ .map(str::to_owned)
+ .map(Ok)
+ .unwrap_or_else(|| required(body, "verification_uri"))?;
+ let invalid = "xAI returned an unsupported sign-in URL.";
+ let parsed = reqwest::Url::parse(&value).map_err(|_| invalid)?;
+ // The provider's device verification page is https://accounts.x.ai/oauth2/device.
+ if parsed.scheme() != "https"
+ || parsed.host_str() != Some("accounts.x.ai")
+ || parsed.port_or_known_default() != Some(443)
+ || !parsed.username().is_empty()
+ || parsed.password().is_some()
+ {
+ return Err(invalid.into());
+ }
+ Ok(parsed.into())
+}
+
+pub fn finish(id: &str) -> Result<(), String> {
+ let flow = active()
+ .lock()
+ .unwrap()
+ .as_ref()
+ .filter(|flow| flow.id == id)
+ .cloned()
+ .ok_or("That sign-in is no longer active.")?;
+ let pending = flow
+ .pending
+ .lock()
+ .unwrap()
+ .take()
+ .ok_or("That sign-in is already being completed.")?;
+ let result = finish_flow(&flow, pending);
+ let mut current = active().lock().unwrap();
+ if current.as_ref().is_some_and(|current| current.id == id) {
+ current.take();
+ }
+ result
+}
+pub(crate) fn read_callback_request(
+ stream: &mut TcpStream,
+ timeout: Duration,
+) -> std::io::Result<String> {
+ // Winsock accept inherits the listener's nonblocking mode; a timeout does not clear it.
+ stream.set_nonblocking(false)?;
+ let deadline = Instant::now() + timeout;
+ let mut bytes = [0; 8192];
+ let mut length = 0;
+ loop {
+ let remaining = deadline.saturating_duration_since(Instant::now());
+ if remaining.is_zero() {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::TimedOut,
+ "Sign-in callback timed out.",
+ ));
+ }
+ stream.set_read_timeout(Some(remaining))?;
+ let count = stream.read(&mut bytes[length..])?;
+ if count == 0 {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::UnexpectedEof,
+ "Incomplete sign-in callback.",
+ ));
+ }
+ length += count;
+ if let Some(end) = bytes[..length].iter().position(|byte| *byte == b'\n') {
+ return Ok(String::from_utf8_lossy(&bytes[..=end]).into_owned());
+ }
+ if length == bytes.len() {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::InvalidData,
+ "Sign-in callback is too large.",
+ ));
+ }
+ }
+}
+
+fn receive_callback(stream: &mut TcpStream, state: &str) -> Result<Option<String>, String> {
+ let request =
+ read_callback_request(stream, Duration::from_secs(2)).map_err(|error| error.to_string())?;
+ let path = request
+ .lines()
+ .next()
+ .and_then(|line| line.split_whitespace().nth(1))
+ .unwrap_or("");
+ let parsed = reqwest::Url::parse(&format!("http://localhost{path}"))
+ .map_err(|_| "Invalid sign-in callback.")?;
+ let query: std::collections::HashMap<_, _> = parsed.query_pairs().into_owned().collect();
+ if parsed.path() != "/oauth/callback" || query.get("state").map(String::as_str) != Some(state) {
+ let _ = stream.write_all(
+ b"HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\nInvalid sign-in callback.",
+ );
+ return Ok(None);
+ }
+ if let Some(error) = query.get("error") {
+ let _ = stream.write_all(b"HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\nSign-in was not approved. Return to OpenBot.");
+ return Err(format!("Google sign-in was not approved: {error}"));
+ }
+ let code = query
+ .get("code")
+ .filter(|v| !v.is_empty())
+ .cloned()
+ .ok_or("Google did not return an authorization code.")?;
+ stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nConnection: close\r\n\r\nReturn to OpenBot to finish signing in.").map_err(|e| e.to_string())?;
+ Ok(Some(code))
+}
+
+fn finish_flow(flow: &Flow, pending: Pending) -> Result<(), String> {
+ let (provider, client_id, client_secret, project, scope, tokens) = match pending {
+ Pending::Google {
+ listener,
+ verifier,
+ state,
+ redirect,
+ client_id,
+ client_secret,
+ project,
+ } => {
+ let deadline = Instant::now() + Duration::from_secs(600);
+ let code = loop {
+ check(flow)?;
+ if Instant::now() >= deadline {
+ return Err("Google sign-in timed out. Try signing in again.".into());
+ }
+ match listener.accept() {
+ Ok((mut stream, _)) => {
+ if let Some(code) = receive_callback(&mut stream, &state)? {
+ break code;
+ }
+ }
+ Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
+ wait(flow, Duration::from_millis(100))?
+ }
+ Err(error) => return Err(error.to_string()),
+ }
+ };
+ let mut form = vec![
+ ("client_id", client_id.as_str()),
+ ("code", code.as_str()),
+ ("code_verifier", verifier.as_str()),
+ ("redirect_uri", redirect.as_str()),
+ ("grant_type", "authorization_code"),
+ ];
+ if let Some(secret) = &client_secret {
+ form.push(("client_secret", secret));
+ }
+ let tokens = response_json(
+ http()?
+ .post("https://oauth2.googleapis.com/token")
+ .form(&form)
+ .send()
+ .map_err(|e| e.to_string())?,
+ )?;
+ (
+ "google",
+ client_id,
+ client_secret,
+ Some(project),
+ GOOGLE_SCOPE,
+ tokens,
+ )
+ }
+ Pending::Xai {
+ client_id,
+ device_code,
+ mut interval,
+ expires,
+ } => {
+ let tokens = loop {
+ if Instant::now() >= expires {
+ return Err("xAI sign-in expired. Try signing in again.".into());
+ }
+ wait(flow, Duration::from_secs(interval))?;
+ let response = http()?
+ .post("https://auth.x.ai/oauth2/token")
+ .form(&[
+ ("grant_type", "urn:ietf:params:oauth:grant-type:device_code"),
+ ("client_id", client_id.as_str()),
+ ("device_code", device_code.as_str()),
+ ])
+ .send()
+ .map_err(|e| e.to_string())?;
+ let status = response.status();
+ let body: serde_json::Value = response
+ .json()
+ .map_err(|_| "xAI returned an unreadable sign-in response.")?;
+ if status.is_success() {
+ break body;
+ }
+ match body.get("error").and_then(|v| v.as_str()) {
+ Some("authorization_pending") => continue,
+ Some("slow_down") => {
+ interval = interval.saturating_add(5);
+ continue;
+ }
+ Some("access_denied") => return Err("xAI sign-in was not approved.".into()),
+ Some("expired_token") => {
+ return Err("xAI sign-in expired. Try signing in again.".into())
+ }
+ _ => {
+ return Err(format!(
+ "xAI sign-in failed ({}). Try signing in again.",
+ status.as_u16()
+ ))
+ }
+ }
+ };
+ ("xai", client_id, None, None, XAI_SCOPE, tokens)
+ }
+ };
+ check(flow)?;
+ let credentials =
+ credentials_from_tokens(provider, client_id, client_secret, project, scope, &tokens)?;
+ write(&flow.root, &credentials, || check(flow))
+}
+fn credentials_from_tokens(
+ provider: &str,
+ client_id: String,
+ client_secret: Option<String>,
+ quota_project: Option<String>,
+ scope: &str,
+ tokens: &serde_json::Value,
+) -> Result<Credentials, String> {
+ let duration = tokens
+ .get("expires_in")
+ .and_then(|v| v.as_u64())
+ .filter(|v| *v > 0)
+ .or_else(|| (provider == "xai").then_some(3600))
+ .ok_or("The provider did not return a token expiry.")?;
+ let now = SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .map_err(|e| e.to_string())?
+ .as_millis() as u64;
+ Ok(Credentials {
+ version: 1,
+ session_id: random(),
+ provider: provider.into(),
+ client_id,
+ client_secret,
+ access_token: required(tokens, "access_token")?,
+ refresh_token: required(tokens, "refresh_token")?,
+ expires_at: now.saturating_add(duration.saturating_mul(1000)),
+ scope: tokens
+ .get("scope")
+ .and_then(|v| v.as_str())
+ .unwrap_or(scope)
+ .into(),
+ quota_project,
+ proxy_token: random(),
+ })
+}
+pub fn read(root: &Path, provider: &str) -> Result<Credentials, String> {
+ let bytes = std::fs::read(root.join(FILE))
+ .map_err(|_| "The saved provider sign-in is unavailable. Sign in again.")?;
+ let saved: Credentials = serde_json::from_slice(&bytes)
+ .map_err(|_| "The saved provider sign-in is unreadable. Sign in again.")?;
+ if saved.version != 1
+ || saved.provider != provider
+ || saved.refresh_token.is_empty()
+ || saved.proxy_token.is_empty()
+ {
+ return Err("The saved sign-in does not match this provider. Sign in again.".into());
+ }
+ Ok(saved)
+}
+fn write(
+ root: &Path,
+ credentials: &Credentials,
+ current: impl FnOnce() -> Result<(), String>,
+) -> Result<(), String> {
+ let path = root.join(FILE);
+ let directory = path.parent().unwrap();
+ std::fs::create_dir_all(directory).map_err(|e| e.to_string())?;
+ let metadata = std::fs::symlink_metadata(directory).map_err(|e| e.to_string())?;
+ if metadata.file_type().is_symlink() || !metadata.is_dir() {
+ return Err("The provider credential directory must be a plain directory.".into());
+ }
+ #[cfg(unix)]
+ {
+ use std::os::unix::fs::PermissionsExt;
+ std::fs::set_permissions(directory, std::fs::Permissions::from_mode(0o700))
+ .map_err(|e| e.to_string())?;
+ }
+ #[cfg(windows)]
+ {
+ use std::os::windows::{fs::MetadataExt, process::CommandExt};
+ if metadata.file_attributes() & 0x400 != 0 {
+ return Err("The provider credential directory cannot be redirected.".into());
+ }
+ // Give new atomically replaced files an owner-only inherited DACL, including runtime refreshes.
+ let script = "$ErrorActionPreference='Stop'; $sid=[System.Security.Principal.WindowsIdentity]::GetCurrent().User; $acl=New-Object System.Security.AccessControl.DirectorySecurity; $acl.SetOwner($sid); $acl.SetAccessRuleProtection($true,$false); $rule=New-Object System.Security.AccessControl.FileSystemAccessRule($sid,'FullControl','ContainerInherit,ObjectInherit','None','Allow'); $acl.AddAccessRule($rule); Set-Acl -LiteralPath $env:OPENBOT_OAUTH_DIRECTORY -AclObject $acl";
+ let output = std::process::Command::new("powershell.exe")
+ .args(["-NoProfile", "-NonInteractive", "-Command", script])
+ .env("OPENBOT_OAUTH_DIRECTORY", directory)
+ // A PowerShell 7 parent passes its incompatible modules through Cargo/OpenBot.
+ // Let Windows PowerShell rebuild its own default module search path.
+ .env_remove("PSModulePath")
+ .creation_flags(0x08000000)
+ .output()
+ .map_err(|e| e.to_string())?;
+ if !output.status.success() {
+ return Err(format!(
+ "OpenBot could not make the provider sign-in private to your Windows account. {}",
+ crate::quiet::said(&output.stderr)
+ ));
+ }
+ }
+ let _lock = credential_lock::acquire(&path)
+ .map_err(|error| format!("Could not save provider sign-in: {error}"))?;
+ current().and_then(|()| {
+ serde_json::to_vec(credentials)
+ .map_err(|e| e.to_string())
+ .and_then(|bytes| {
+ crate::env::write_private_file(&path, &bytes).map_err(|e| e.to_string())
+ })
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ #[test]
+ fn xai_verification_url_rejects_unsafe_or_foreign_destinations() {
+ for url in [
+ "http://accounts.x.ai/oauth2/device",
+ "https://accounts.x.ai.evil.example/oauth2/device",
+ "https://evil.example/oauth2/device",
+ "https://[email protected]/oauth2/device",
+ "https://user:[email protected]/oauth2/device",
+ "https://accounts.x.ai:444/oauth2/device",
+ "javascript:alert(1)",
+ "file:///tmp/signin",
+ "mailto:[email protected]",
+ "/oauth2/device",
+ ] {
+ for field in ["verification_uri", "verification_uri_complete"] {
+ let body = serde_json::json!({field: url});
+ assert!(
+ xai_verification_url(&body).is_err(),
+ "accepted {field}: {url}"
+ );
+ }
+ }
+ }
+
+ #[test]
+ fn xai_verification_url_preserves_the_provider_code() {
+ let plain = "https://accounts.x.ai/oauth2/device";
+ let complete = "https://accounts.x.ai/oauth2/device?user_code=ABCD-EFGH&referrer=openbot";
+ assert_eq!(
+ xai_verification_url(&serde_json::json!({"verification_uri": plain})).unwrap(),
+ plain
+ );
+ assert_eq!(xai_verification_url(&serde_json::json!({"verification_uri": plain, "verification_uri_complete": complete})).unwrap(), complete);
+ assert_eq!(
+ xai_verification_url(&serde_json::json!({"verification_uri_complete": complete}))
+ .unwrap(),
+ complete
+ );
+ }
+
+ #[test]
+ fn callback_read_keeps_its_time_and_size_bounds() {
+ for (payload, expected) in [
+ (Vec::new(), std::io::ErrorKind::TimedOut),
+ (vec![b'x'; 8192], std::io::ErrorKind::InvalidData),
+ ] {
+ let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
+ let mut browser = TcpStream::connect(listener.local_addr().unwrap()).unwrap();
+ let (mut stream, _) = listener.accept().unwrap();
+ browser.write_all(&payload).unwrap();
+ let started = Instant::now();
+ let error = read_callback_request(&mut stream, Duration::from_millis(100)).unwrap_err();
+ if expected == std::io::ErrorKind::TimedOut {
+ assert!(matches!(
+ error.kind(),
+ std::io::ErrorKind::TimedOut | std::io::ErrorKind::WouldBlock
+ ));
+ assert!(started.elapsed() >= Duration::from_millis(80));
+ } else {
+ assert_eq!(error.kind(), expected);
+ }
+ assert!(started.elapsed() < Duration::from_secs(2));
+ }
+ }
+
+ fn callback_over_tcp(nonblocking: bool, fragmented: bool) {
+ let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
+ listener.set_nonblocking(true).unwrap();
+ let mut browser = TcpStream::connect(listener.local_addr().unwrap()).unwrap();
+ browser
+ .set_read_timeout(Some(Duration::from_secs(3)))
+ .unwrap();
+ let deadline = Instant::now() + Duration::from_secs(2);
+ let (mut stream, _) = loop {
+ match listener.accept() {
+ Ok(accepted) => break accepted,
+ Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
+ assert!(
+ Instant::now() < deadline,
+ "browser connection was not accepted"
+ );
+ std::thread::yield_now();
+ }
+ Err(error) => panic!("browser connection failed: {error}"),
+ }
+ };
+ // Unix does not consistently inherit this flag; model the Windows accept behavior.
+ if nonblocking {
+ stream.set_nonblocking(true).unwrap();
+ } else {
+ stream.set_nonblocking(false).unwrap();
+ }
+ let request = b"GET /oauth/callback?state=expected&code=synthetic HTTP/1.1\r\nHost: localhost\r\n\r\n";
+ let split = if fragmented { 18 } else { 0 };
+ if fragmented {
+ browser.write_all(&request[..split]).unwrap();
+ }
+ let (sender, receiver) = std::sync::mpsc::channel();
+ let worker = std::thread::spawn(move || {
+ sender
+ .send(receive_callback(&mut stream, "expected"))
+ .unwrap();
+ });
+ let early = receiver.recv_timeout(Duration::from_millis(100));
+ if !matches!(early, Err(std::sync::mpsc::RecvTimeoutError::Timeout)) {
+ worker.join().unwrap();
+ panic!("callback completed before its request line arrived: {early:?}");
+ }
+ browser.write_all(&request[split..]).unwrap();
+ assert_eq!(
+ receiver
+ .recv_timeout(Duration::from_secs(3))
+ .unwrap()
+ .unwrap(),
+ Some("synthetic".into())
+ );
+ let mut response = String::new();
+ browser.read_to_string(&mut response).unwrap();
+ assert!(response.starts_with("HTTP/1.1 200 OK\r\n"));
+ worker.join().unwrap();
+ }
+
+ #[test]
+ fn callback_waits_for_delayed_get_on_nonblocking_stream() {
+ callback_over_tcp(true, false);
+ }
+
+ #[test]
+ fn callback_waits_for_fragmented_request_line() {
+ callback_over_tcp(false, true);
+ }
+
+ #[test]
+ fn tokens_require_refresh_and_expiry() {
+ let missing = serde_json::json!({"access_token":"synthetic", "expires_in":3600});
+ assert!(
+ credentials_from_tokens("xai", "client".into(), None, None, XAI_SCOPE, &missing)
+ .is_err()
+ );
+ let complete = serde_json::json!({"access_token":"synthetic", "refresh_token":"synthetic-refresh", "expires_in":3600});
+ let saved =
+ credentials_from_tokens("xai", "client".into(), None, None, XAI_SCOPE, &complete)
+ .unwrap();
+ assert_eq!(saved.provider, "xai");
+ assert!(saved.expires_at > 0);
+ assert_ne!(saved.proxy_token, saved.access_token);
+ }
+ #[test]
+ fn xai_tokens_accept_documented_missing_expiry() {
+ let tokens =
+ serde_json::json!({"access_token":"synthetic", "refresh_token":"synthetic-refresh"});
+ assert!(
+ credentials_from_tokens("xai", "client".into(), None, None, XAI_SCOPE, &tokens).is_ok()
+ );
+ assert!(credentials_from_tokens(
+ "google",
+ "client".into(),
+ None,
+ Some("project".into()),
+ GOOGLE_SCOPE,
+ &tokens
+ )
+ .is_err());
+ }
+ #[test]
+ fn late_begin_cannot_cancel_newer_authorization() {
+ let root = crate::test_support::temp_root("oauth-out-of-order");
+ let delayed = reserve(&root);
+ let newer = reserve(&root);
+ assert!(check(&delayed).is_err());
+ assert!(check(&newer).is_ok());
+ cancel(&delayed.id);
+ assert_eq!(active().lock().unwrap().as_ref().unwrap().id, newer.id);
+ assert!(check(&newer).is_ok());
+ cancel(&newer.id);
+ }
+ #[cfg(windows)]
+ #[test]
+ fn windows_oauth_persistence_ignores_incompatible_parent_powershell_modules() {
+ let root = crate::test_support::temp_root("oauth-parent-modules");
+ let module = root.join("Microsoft.PowerShell.Security");
+ std::fs::create_dir_all(&module).unwrap();
+ // A module with a newer engine requirement models the PS7 path inherited through Cargo.
+ std::fs::write(
+ module.join("Microsoft.PowerShell.Security.psd1"),
+ "@{ModuleVersion='99.0';PowerShellVersion='99.0';CmdletsToExport=@('Set-Acl')}",
+ )
+ .unwrap();
+ let output = crate::quiet::command(std::env::current_exe().unwrap())
+ .args([
+ "--exact",
+ "provider_oauth::tests::persisted_credentials_remain_provider_bound",
+ "--nocapture",
+ ])
+ .env("PSModulePath", &root)
+ .output()
+ .unwrap();
+ std::fs::remove_dir_all(root).unwrap();
+ assert!(
+ output.status.success(),
+ "{}\n{}",
+ crate::quiet::said(&output.stdout),
+ crate::quiet::said(&output.stderr)
+ );
+ }
+ #[test]
+ fn persisted_credentials_remain_provider_bound() {
+ let root = crate::test_support::temp_root("provider-oauth");
+ let tokens = serde_json::json!({"access_token":"synthetic", "refresh_token":"synthetic-refresh", "expires_in":3600});
+ let saved = credentials_from_tokens("xai", "client".into(), None, None, XAI_SCOPE, &tokens)
+ .unwrap();
+ write(&root, &saved, || Ok(())).unwrap();
+ assert_eq!(read(&root, "xai").unwrap().session_id, saved.session_id);
+ assert!(read(&root, "google").is_err());
+ assert!(root.join(format!("{FILE}.lock/owner.lock")).is_file());
+ std::fs::remove_dir_all(root).unwrap();
+ }
+ struct LockChild(std::process::Child);
+ impl Drop for LockChild {
+ fn drop(&mut self) {
+ let _ = self.0.kill();
+ let _ = self.0.wait();
+ }
+ }
+
+ #[test]
+ fn credential_lock_child_process() {
+ let Some(path) = std::env::var_os("OPENBOT_TEST_CREDENTIAL_LOCK_CHILD") else {
+ return;
+ };
+ let _lock = credential_lock::acquire(Path::new(&path)).unwrap();
+ println!("locked");
+ std::io::stdout().flush().unwrap();
+ std::io::stdin().read_line(&mut String::new()).unwrap();
+ }
+
+ fn lock_child_ready(child: &mut LockChild) -> std::sync::mpsc::Receiver<String> {
+ use std::io::BufRead;
+ let stdout = child.0.stdout.take().unwrap();
+ let (send, receive) = std::sync::mpsc::channel();
+ std::thread::spawn(move || {
+ let mut reader = std::io::BufReader::new(stdout);
+ let mut line = String::new();
+ loop {
+ match reader.read_line(&mut line) {
+ Ok(0) => {
+ let _ = send.send("child exited without a lock".into());
+ return;
+ }
+ Ok(_) if line.trim() == "locked" => {
+ let _ = send.send("locked".into());
+ return;
+ }
+ Ok(_) => line.clear(),
+ Err(error) => {
+ let _ = send.send(error.to_string());
+ return;
+ }
+ }
+ }
+ });
+ receive
+ }
+
+ #[test]
+ fn credential_lock_excludes_bun_in_both_directions_and_recovers_after_kill() {
+ use std::process::Stdio;
+ let root = crate::test_support::temp_root("provider-oauth-cross-writer");
+ std::fs::create_dir_all(&root).unwrap();
+ let path = root.join("model-oauth.json");
+ let native = credential_lock::acquire(&path).unwrap();
+ let fixture = Path::new(env!("CARGO_MANIFEST_DIR"))
+ .join("../../server/tests/fixtures/provider-oauth-lock-owner.ts");
+ let bun = std::env::var_os("OPENBOT_TEST_BUN").unwrap_or_else(|| "bun".into());
+ let mut child = LockChild(
+ crate::quiet::command(bun)
+ .args([fixture.as_os_str(), path.as_os_str()])
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::inherit())
+ .spawn()
+ .unwrap(),
+ );
+ let ready = lock_child_ready(&mut child);
+ assert!(matches!(
+ ready.recv_timeout(Duration::from_millis(150)),
+ Err(std::sync::mpsc::RecvTimeoutError::Timeout)
+ ));
+ drop(native);
+ assert_eq!(
+ ready.recv_timeout(Duration::from_secs(15)).unwrap(),
+ "locked"
+ );
+ let other_path = path.clone();
+ let (send, receive) = std::sync::mpsc::channel();
+ let waiter = std::thread::spawn(move || {
+ send.send(credential_lock::acquire(&other_path)).unwrap();
+ });
+ assert!(matches!(
+ receive.recv_timeout(Duration::from_millis(150)),
+ Err(std::sync::mpsc::RecvTimeoutError::Timeout)
+ ));
+ child.0.kill().unwrap();
+ child.0.wait().unwrap();
+ drop(
+ receive
+ .recv_timeout(Duration::from_secs(5))
+ .unwrap()
+ .unwrap(),
+ );
+ waiter.join().unwrap();
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
+ #[test]
+ fn credential_lock_recovers_after_native_process_is_killed() {
+ use std::process::Stdio;
+ let root = crate::test_support::temp_root("provider-oauth-native-kill");
+ std::fs::create_dir_all(&root).unwrap();
+ let path = root.join("model-oauth.json");
+ let mut child = LockChild(
+ crate::quiet::command(std::env::current_exe().unwrap())
+ .args([
+ "--exact",
+ "provider_oauth::tests::credential_lock_child_process",
+ "--nocapture",
+ ])
+ .env("OPENBOT_TEST_CREDENTIAL_LOCK_CHILD", &path)
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::inherit())
+ .spawn()
+ .unwrap(),
+ );
+ let ready = lock_child_ready(&mut child);
+ assert_eq!(
+ ready.recv_timeout(Duration::from_secs(5)).unwrap(),
+ "locked"
+ );
+ child.0.kill().unwrap();
+ child.0.wait().unwrap();
+ drop(credential_lock::acquire(&path).unwrap());
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
+ #[test]
+ fn credential_replacement_waits_for_existing_rotation_owner() {
+ let root = crate::test_support::temp_root("provider-oauth-replacement");
+ let tokens = serde_json::json!({"access_token":"synthetic", "refresh_token":"synthetic-refresh", "expires_in":3600});
+ let old = credentials_from_tokens("xai", "client".into(), None, None, XAI_SCOPE, &tokens)
+ .unwrap();
+ write(&root, &old, || Ok(())).unwrap();
+ let lock = credential_lock::acquire(&root.join(FILE)).unwrap();
+ let new = credentials_from_tokens("xai", "client".into(), None, None, XAI_SCOPE, &tokens)
+ .unwrap();
+ let newer_session = new.session_id.clone();
+ let other_root = root.clone();
+ let (send, receive) = std::sync::mpsc::channel();
+ let writer =
+ std::thread::spawn(move || send.send(write(&other_root, &new, || Ok(()))).unwrap());
+ assert!(matches!(
+ receive.recv_timeout(Duration::from_millis(150)),
+ Err(std::sync::mpsc::RecvTimeoutError::Timeout)
+ ));
+ assert_eq!(read(&root, "xai").unwrap().session_id, old.session_id);
+ drop(lock);
+ receive
+ .recv_timeout(Duration::from_secs(5))
+ .unwrap()
+ .unwrap();
+ writer.join().unwrap();
+ assert_eq!(read(&root, "xai").unwrap().session_id, newer_session);
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
+ #[test]
+ fn credential_save_recovers_abandoned_legacy_lock_directory() {
+ let root = crate::test_support::temp_root("provider-oauth-orphan");
+ std::fs::create_dir_all(root.join(format!("{FILE}.lock"))).unwrap();
+ #[cfg(unix)]
+ {
+ use std::os::unix::fs::PermissionsExt;
+ std::fs::set_permissions(
+ root.join(format!("{FILE}.lock")),
+ std::fs::Permissions::from_mode(0o755),
+ )
+ .unwrap();
+ }
+ let tokens = serde_json::json!({"access_token":"synthetic", "refresh_token":"synthetic-refresh", "expires_in":3600});
+ let saved = credentials_from_tokens("xai", "client".into(), None, None, XAI_SCOPE, &tokens)
+ .unwrap();
+ let result = write(&root, &saved, || Ok(()));
+ assert!(
+ result.is_ok(),
+ "abandoned directory blocked sign-in: {result:?}"
+ );
+ assert_eq!(read(&root, "xai").unwrap().session_id, saved.session_id);
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
+ #[test]
+ fn canceled_sign_in_cannot_replace_current_credentials() {
+ let root = crate::test_support::temp_root("provider-oauth-canceled");
+ let tokens = serde_json::json!({"access_token":"synthetic", "refresh_token":"synthetic-refresh", "expires_in":3600});
+ let saved = credentials_from_tokens("xai", "client".into(), None, None, XAI_SCOPE, &tokens)
+ .unwrap();
+ write(&root, &saved, || Ok(())).unwrap();
+ let mut replacement = saved.clone();
+ replacement.session_id = "canceled".into();
+ assert!(write(&root, &replacement, || Err("canceled".into())).is_err());
+ assert_eq!(read(&root, "xai").unwrap().session_id, saved.session_id);
+ assert!(root.join(format!("{FILE}.lock/owner.lock")).is_file());
+ std::fs::remove_dir_all(root).unwrap();
+ }
+}
diff --git a/desktop/src-tauri/src/provider_oauth_lock.rs b/desktop/src-tauri/src/provider_oauth_lock.rs
new file mode 100644
index 00000000..71c26e21
--- /dev/null
+++ b/desktop/src-tauri/src/provider_oauth_lock.rs
@@ -0,0 +1,111 @@
+//! Shared with server/src/provider-oauth-lock.ts. Keep the directory and lock
+//! inode permanently; OS handle ownership releases exclusion after a crash.
+use std::{
+ fs::{File, OpenOptions},
+ io,
+ path::{Path, PathBuf},
+ time::{Duration, Instant},
+};
+
+pub fn acquire(credential: &Path) -> io::Result<File> {
+ let mut name = credential.as_os_str().to_os_string();
+ name.push(".lock");
+ let directory = PathBuf::from(name);
+ let mut builder = std::fs::DirBuilder::new();
+ #[cfg(unix)]
+ {
+ use std::os::unix::fs::DirBuilderExt;
+ builder.mode(0o700);
+ }
+ match builder.create(&directory) {
+ Ok(()) => (),
+ Err(error) if error.kind() == io::ErrorKind::AlreadyExists => (),
+ Err(error) => return Err(error),
+ }
+ let metadata = std::fs::symlink_metadata(&directory)?;
+ if !metadata.is_dir() || metadata.file_type().is_symlink() {
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidInput,
+ "Invalid credential lock directory.",
+ ));
+ }
+ validate_private(&metadata, true)?;
+ let path = directory.join("owner.lock");
+ let deadline = Instant::now() + Duration::from_secs(5);
+ let mut options = OpenOptions::new();
+ options.read(true).write(true).create(true);
+ #[cfg(unix)]
+ {
+ use std::os::unix::{fs::OpenOptionsExt, io::AsRawFd};
+ options.mode(0o600).custom_flags(libc::O_NOFOLLOW);
+ let file = options.open(path)?;
+ validate_file(&file)?;
+ loop {
+ // SAFETY: file owns a valid descriptor for the lifetime of this call.
+ if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == 0 {
+ return Ok(file);
+ }
+ let error = io::Error::last_os_error();
+ if error.kind() != io::ErrorKind::WouldBlock || Instant::now() >= deadline {
+ return Err(error);
+ }
+ std::thread::sleep(Duration::from_millis(25));
+ }
+ }
+ #[cfg(windows)]
+ {
+ use std::os::windows::fs::OpenOptionsExt;
+ // Exactly the CreateFileW sharing/no-follow mode used by the Bun helper.
+ options.share_mode(0).custom_flags(0x00200000); // FILE_FLAG_OPEN_REPARSE_POINT
+ loop {
+ match options.open(&path) {
+ Ok(file) => {
+ validate_file(&file)?;
+ return Ok(file);
+ }
+ Err(error) if error.raw_os_error() == Some(32) && Instant::now() < deadline => {
+ std::thread::sleep(Duration::from_millis(25));
+ }
+ Err(error) => return Err(error),
+ }
+ }
+ }
+}
+
+fn validate_file(file: &File) -> io::Result<()> {
+ let metadata = file.metadata()?;
+ if !metadata.is_file() {
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidInput,
+ "Invalid credential lock file.",
+ ));
+ }
+ validate_private(&metadata, false)
+}
+
+fn validate_private(metadata: &std::fs::Metadata, directory: bool) -> io::Result<()> {
+ #[cfg(unix)]
+ {
+ use std::os::unix::fs::PermissionsExt;
+ // Legacy mkdir directories may be 0755, but other users must not be
+ // able to replace their entries. The lock file remains owner-only.
+ if metadata.permissions().mode() & (if directory { 0o022 } else { 0o077 }) != 0 {
+ return Err(io::Error::new(
+ io::ErrorKind::PermissionDenied,
+ "Credential lock is not private.",
+ ));
+ }
+ }
+ #[cfg(windows)]
+ {
+ use std::os::windows::fs::MetadataExt;
+ let _ = directory;
+ if metadata.file_attributes() & 0x400 != 0 {
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidInput,
+ "Credential lock cannot be redirected.",
+ ));
+ }
+ }
+ Ok(())
+}
diff --git a/desktop/src-tauri/src/pull_metrics.rs b/desktop/src-tauri/src/pull_metrics.rs
index a7408744..0b38aff4 100644
--- a/desktop/src-tauri/src/pull_metrics.rs
+++ b/desktop/src-tauri/src/pull_metrics.rs
@@ -1,8 +1,9 @@
//! Metrics for an explicit image pull, before containers or provider sign-in start.
use std::collections::HashMap;
-use std::io::Write;
-use std::process::{Command, Stdio};
+use std::io::{BufRead, BufReader, Read, Write};
+use std::process::{Command, Output, Stdio};
+use std::sync::mpsc::{sync_channel, SyncSender};
use std::time::Instant;
use serde::Deserialize;
@@ -76,38 +77,49 @@ struct Progress {
current: Option<u64>,
}
+#[derive(Default)]
+struct DownloadBytes(HashMap<String, u64>);
+
+impl DownloadBytes {
+ fn observe(&mut self, progress: Progress) {
+ if progress.text == "Downloading"
+ && !progress.id.is_empty()
+ && !progress.parent_id.as_deref().unwrap_or_default().is_empty()
+ {
+ if let Some(current) = progress.current {
+ self.0
+ .entry(progress.id)
+ .and_modify(|maximum| *maximum = (*maximum).max(current))
+ .or_insert(current);
+ }
+ }
+ }
+
+ fn total(&self) -> Option<u64> {
+ if self.0.is_empty() {
+ return None;
+ }
+ self.0
+ .values()
+ .try_fold(0_u64, |sum, current| sum.checked_add(*current))
+ }
+}
+
/// Compose's JSON writer carries Docker's byte counters as integers:
/// https://github.com/docker/compose/blob/v2.39.2/pkg/compose/pull.go#L391-L440
/// The same layer can appear beneath multiple services. Keep its maximum download counter,
/// regardless of parent, and never add extraction progress or the advertised total size.
fn download_bytes(stdout: &[u8], stderr: &[u8]) -> Option<u64> {
- let mut layers: HashMap<String, u64> = HashMap::new();
+ let mut layers = DownloadBytes::default();
for output in [stdout, stderr] {
for line in output.split(|byte| *byte == b'\n') {
let Ok(progress) = serde_json::from_slice::<Progress>(line) else {
continue;
};
- if progress.text != "Downloading"
- || progress.id.is_empty()
- || progress.parent_id.as_deref().unwrap_or_default().is_empty()
- {
- continue;
- }
- if let Some(current) = progress.current {
- layers
- .entry(progress.id)
- .and_modify(|maximum| *maximum = (*maximum).max(current))
- .or_insert(current);
- }
+ layers.observe(progress);
}
}
- if layers.is_empty() {
- None
- } else {
- layers
- .values()
- .try_fold(0_u64, |sum, current| sum.checked_add(*current))
- }
+ layers.total()
}
/// Pull a provider sign-in image without starting its CLI or creating a container.
@@ -116,6 +128,7 @@ fn download_bytes(stdout: &[u8], stderr: &[u8]) -> Option<u64> {
pub fn pull_image(
engine: &Address,
image: &str,
+ on_progress: impl FnMut(u64),
on_complete: impl FnOnce(PullMetrics),
) -> Result<(), Problem> {
if crate::preparation::image_present(engine, image)? {
@@ -124,7 +137,7 @@ pub fn pull_image(
let Some(json_progress) = compose_pull_progress(engine) else {
let mut command = engine.command();
command.args(["pull", image]);
- return run(command, None, false, on_complete);
+ return run_with_progress(command, None, false, on_progress, on_complete);
};
let mut command = engine.command();
command.arg("compose");
@@ -141,10 +154,11 @@ pub fn pull_image(
"missing",
]);
let project = serde_json::json!({"services": {"image": {"image": image}}}).to_string();
- run(
+ run_with_progress(
command,
Some(project.as_bytes()),
json_progress,
+ on_progress,
on_complete,
)
}
@@ -152,9 +166,19 @@ pub fn pull_image(
/// Complete one explicit pull and report its outcome before the caller can start containers.
/// A failed pull is returned as the same two-part Problem used by the existing startup path.
pub(crate) fn run(
+ command: Command,
+ input: Option<&[u8]>,
+ json_progress: bool,
+ on_complete: impl FnOnce(PullMetrics),
+) -> Result<(), Problem> {
+ run_with_progress(command, input, json_progress, |_| {}, on_complete)
+}
+
+fn run_with_progress(
mut command: Command,
input: Option<&[u8]>,
json_progress: bool,
+ mut on_progress: impl FnMut(u64),
on_complete: impl FnOnce(PullMetrics),
) -> Result<(), Problem> {
command
@@ -180,7 +204,41 @@ pub(crate) fn run(
return Err(error);
}
}
- child.wait_with_output()
+ // Drain both pipes concurrently, just as wait_with_output does, while forwarding only
+ // structured byte counters. Raw engine output stays in the existing error diagnostics.
+ let stdout = child.stdout.take().expect("piped pull stdout");
+ let stderr = child.stderr.take().expect("piped pull stderr");
+ std::thread::scope(|scope| {
+ let (sender, receiver) = sync_channel(64);
+ let stdout_sender = sender.clone();
+ let out = scope.spawn(move || read_output(stdout, json_progress, stdout_sender));
+ let err = scope.spawn(move || read_output(stderr, json_progress, sender));
+ let mut layers = DownloadBytes::default();
+ let mut last = None;
+ for progress in receiver {
+ layers.observe(progress);
+ let total = layers.total();
+ if total != last {
+ if let Some(bytes) = total {
+ on_progress(bytes);
+ }
+ last = total;
+ }
+ }
+ let stdout = out
+ .join()
+ .map_err(|_| std::io::Error::other("pull stdout reader panicked"));
+ let stderr = err
+ .join()
+ .map_err(|_| std::io::Error::other("pull stderr reader panicked"));
+ // Always reap the child, including when reading a pipe failed.
+ let status = child.wait()?;
+ Ok(Output {
+ status,
+ stdout: stdout??,
+ stderr: stderr??,
+ })
+ })
})();
let duration_ms = started.elapsed().as_millis().min(u64::MAX as u128) as u64;
let success = output.as_ref().is_ok_and(|output| output.status.success());
@@ -215,10 +273,85 @@ pub(crate) fn run(
Err(Problem::with(crate::problem::said_about(&raw), raw))
}
+fn read_output(
+ pipe: impl Read,
+ json_progress: bool,
+ sender: SyncSender<Progress>,
+) -> std::io::Result<Vec<u8>> {
+ let mut reader = BufReader::new(pipe);
+ let mut output = Vec::new();
+ let mut line = Vec::new();
+ loop {
+ line.clear();
+ if reader.read_until(b'\n', &mut line)? == 0 {
+ return Ok(output);
+ }
+ output.extend_from_slice(&line);
+ if json_progress {
+ if let Ok(progress) = serde_json::from_slice(&line) {
+ sender
+ .send(progress)
+ .map_err(|_| std::io::Error::other("pull progress receiver closed"))?;
+ }
+ }
+ }
+}
+
#[cfg(test)]
mod tests {
use super::*;
+ #[test]
+ fn streams_download_bytes_before_the_child_exits() {
+ let root = crate::test_support::temp_root("live-pull-progress");
+ std::fs::create_dir_all(&root).unwrap();
+ let source = root.join("progress.rs");
+ let binary = root.join(format!("progress{}", std::env::consts::EXE_SUFFIX));
+ let acknowledgement = root.join("progress-observed");
+ std::fs::write(
+ &source,
+ r#"
+use std::io::Write;
+fn main() {
+ let acknowledgement = std::env::args().nth(1).unwrap();
+ println!("{{\"id\":\"a\",\"parent_id\":\"image\",\"text\":\"Downloading\",\"current\":7}}");
+ std::io::stdout().flush().unwrap();
+ eprintln!("{{\"id\":\"b\",\"parent_id\":\"image\",\"text\":\"Downloading\",\"current\":5}}");
+ for _ in 0..300 {
+ if std::path::Path::new(&acknowledgement).exists() { return; }
+ std::thread::sleep(std::time::Duration::from_millis(10));
+ }
+ eprintln!("progress was not delivered while the pull was running");
+ std::process::exit(71);
+}
+"#,
+ )
+ .unwrap();
+ crate::test_support::compile_fixture(&source, &binary);
+ let mut command = crate::quiet::command(&binary);
+ command.arg(&acknowledgement);
+ let mut updates = Vec::new();
+ let mut metrics = Vec::new();
+ let result = run_with_progress(
+ command,
+ None,
+ true,
+ |bytes| {
+ updates.push(bytes);
+ if bytes == 12 {
+ std::fs::write(&acknowledgement, "received").unwrap();
+ }
+ },
+ |metric| metrics.push(metric),
+ );
+ std::fs::remove_dir_all(root).unwrap();
+ assert!(result.is_ok(), "{result:?}");
+ assert_eq!(updates.last(), Some(&12));
+ assert_eq!(metrics.len(), 1);
+ assert_eq!(metrics[0].bytes, Some(12));
+ assert_eq!(metrics[0].outcome, Outcome::Success);
+ }
+
#[test]
fn older_compose_explicitly_downloads_missing_images_and_reuses_cached_images() {
if crate::test_support::isolated_process("pull_metrics::tests::older_compose_explicitly_downloads_missing_images_and_reuses_cached_images") { return; }
@@ -246,16 +379,26 @@ fn main() {
std::env::set_var("PATH", &root);
let address = Address::new(crate::engine::Engine::Docker, None);
let mut outcomes = Vec::new();
- pull_image(&address, "synthetic-image", |metric| {
- outcomes.push(metric.outcome)
- })
+ pull_image(
+ &address,
+ "synthetic-image",
+ |_| {},
+ |metric| outcomes.push(metric.outcome),
+ )
.unwrap();
- pull_image(&address, "synthetic-image", |_| {
- panic!("cached image must not be downloaded again")
- })
+ pull_image(
+ &address,
+ "synthetic-image",
+ |_| {},
+ |_| panic!("cached image must not be downloaded again"),
+ )
.unwrap();
- assert!(pull_image(&address, "missing-image", |metric| outcomes
- .push(metric.outcome))
+ assert!(pull_image(
+ &address,
+ "missing-image",
+ |_| {},
+ |metric| outcomes.push(metric.outcome)
+ )
.is_err());
assert_eq!(outcomes, [Outcome::Success, Outcome::Failure]);
std::fs::remove_dir_all(root).unwrap();
diff --git a/desktop/src-tauri/src/saved_intent.rs b/desktop/src-tauri/src/saved_intent.rs
index 4294fc3b..255b9286 100644
--- a/desktop/src-tauri/src/saved_intent.rs
+++ b/desktop/src-tauri/src/saved_intent.rs
@@ -19,6 +19,8 @@ pub enum Category {
ClaudePlan,
ChatGptPlan,
CompatibleEndpointApiKey,
+ GoogleOauth,
+ XaiOauth,
}
// A closed enum intentionally cannot contain fields from the secret-bearing ChosenModel request.
@@ -30,6 +32,8 @@ pub enum ModelIntent {
ClaudePlan,
ChatGptPlan,
CompatibleEndpoint,
+ GoogleOauth,
+ XaiOauth,
}
#[derive(Debug, serde::Serialize, serde::Deserialize)]
@@ -102,6 +106,11 @@ impl SavedIntent {
}
// write_plan_store persists the selected plan, and clears it for other selections.
self.categories.remove(&Category::ChatGptPlan);
+ self.categories.remove(&Category::GoogleOauth);
+ self.categories.remove(&Category::XaiOauth);
+ if matches!(credential, ModelCredential::ProviderOAuth { .. }) {
+ self.categories.remove(&Category::OpenAiApiKey);
+ }
if matches!(credential, ModelCredential::None) {
self.model = None;
return;
@@ -118,6 +127,15 @@ impl SavedIntent {
ModelIntent::ChatGptPlan
}
ModelCredential::Compatible { .. } => ModelIntent::CompatibleEndpoint,
+ ModelCredential::ProviderOAuth { provider, .. } => {
+ if provider == "google" {
+ self.categories.insert(Category::GoogleOauth);
+ ModelIntent::GoogleOauth
+ } else {
+ self.categories.insert(Category::XaiOauth);
+ ModelIntent::XaiOauth
+ }
+ }
});
}
diff --git a/desktop/src-tauri/src/stack.rs b/desktop/src-tauri/src/stack.rs
index b51371a8..22e01c84 100644
--- a/desktop/src-tauri/src/stack.rs
+++ b/desktop/src-tauri/src/stack.rs
@@ -49,9 +49,9 @@ impl BundledBots {
pub fn for_credential(credential: &crate::env::ModelCredential) -> Self {
use crate::env::ModelCredential;
match credential {
- ModelCredential::OpenAi { .. } | ModelCredential::Compatible { .. } => {
- Self::openai_compatible()
- }
+ ModelCredential::OpenAi { .. }
+ | ModelCredential::Compatible { .. }
+ | ModelCredential::ProviderOAuth { .. } => Self::openai_compatible(),
ModelCredential::Anthropic { .. } => Self::anthropic(),
ModelCredential::None
| ModelCredential::ClaudePlan { .. }
@@ -187,6 +187,16 @@ pub fn postgres_volume_exists(
root: &Path,
secrets: &Secrets,
) -> Result<bool, Problem> {
+ let configuration = postgres_configuration(engine, root, secrets)?;
+ let volume = postgres_volume_name(&configuration)?;
+ named_volume_exists(engine, root, &volume)
+}
+
+fn postgres_configuration(
+ engine: &Address,
+ root: &Path,
+ secrets: &Secrets,
+) -> Result<Vec<u8>, Problem> {
let configuration = compose_command(engine, root, secrets)
.args(["config", "--format", "json"])
.output()
@@ -199,7 +209,10 @@ pub fn postgres_volume_exists(
configuration.status
)));
}
- let volume = postgres_volume_name(&configuration.stdout)?;
+ Ok(configuration.stdout)
+}
+
+fn named_volume_exists(engine: &Address, root: &Path, volume: &str) -> Result<bool, Problem> {
let inventory = engine
.command()
.current_dir(root)
@@ -224,9 +237,134 @@ fn postgres_volume_problem(detail: impl Into<String>) -> Problem {
)
}
+/// A surviving database is recoverable only when Compose and the engine agree it is owned.
+pub fn leftover_database_volume(
+ engine: &Address,
+ root: &Path,
+ secrets: &Secrets,
+) -> Result<Option<String>, Problem> {
+ let configuration = postgres_configuration(engine, root, secrets)?;
+ let config: serde_json::Value = serde_json::from_slice(&configuration)
+ .map_err(|_| postgres_volume_problem("Compose config did not return valid JSON."))?;
+ let Some((source, definition)) = postgres_data_volume(&config) else {
+ return Ok(None);
+ };
+ let Some(project) = config["name"].as_str().filter(|name| !name.is_empty()) else {
+ return Ok(None);
+ };
+ let Some(name) = definition["name"].as_str() else {
+ return Ok(None);
+ };
+ // Compose's explicit names and external volumes can refer to somebody else's database.
+ // Permit only ordinary project-scoped, local storage, even if a custom volume has labels.
+ if name != format!("{project}_{source}")
+ || !name.bytes().enumerate().all(|(index, byte)| {
+ byte.is_ascii_alphanumeric() || (index > 0 && b"_.-".contains(&byte))
+ })
+ || !matches!(
+ definition.get("external"),
+ None | Some(serde_json::Value::Bool(false))
+ )
+ || definition["driver"]
+ .as_str()
+ .is_some_and(|driver| driver != "local")
+ || !empty_volume_options(&definition["driver_opts"])
+ || config["services"].as_object().is_some_and(|services| {
+ services.iter().any(|(service, configuration)| {
+ service != "postgres"
+ && configuration["volumes"].as_array().is_some_and(|mounts| {
+ mounts.iter().any(|mount| {
+ mount["source"].as_str().is_some_and(|other_source| {
+ other_source == source
+ || config["volumes"][other_source]["name"].as_str()
+ == Some(name)
+ })
+ })
+ })
+ })
+ })
+ {
+ return Ok(None);
+ }
+ if !named_volume_exists(engine, root, name)? {
+ return Ok(None);
+ }
+ let inspect = engine
+ .command()
+ .current_dir(root)
+ .args(["volume", "inspect", name])
+ .output()
+ .map_err(|error| {
+ postgres_volume_problem(format!("Could not inspect the database volume: {error}"))
+ })?;
+ if !inspect.status.success() {
+ return Err(postgres_volume_problem(format!("Database volume inspection exited with {}. Output omitted because it can contain credentials.", inspect.status)));
+ }
+ let inspected: serde_json::Value = serde_json::from_slice(&inspect.stdout).map_err(|_| {
+ postgres_volume_problem("Database volume inspection did not return valid JSON.")
+ })?;
+ let Some(volumes) = inspected.as_array().filter(|volumes| volumes.len() == 1) else {
+ return Ok(None);
+ };
+ let volume = &volumes[0];
+ // Podman accepts unique name prefixes. Exact inventory and inspect matches keep the command
+ // tied to the full name the person confirmed, never a similarly named backup.
+ Ok((volume["Name"].as_str() == Some(name)
+ && volume["Driver"].as_str() == Some("local")
+ && empty_volume_options(&volume["Options"])
+ && volume["Labels"]["com.docker.compose.project"].as_str() == Some(project)
+ && volume["Labels"]["com.docker.compose.volume"].as_str() == Some(source))
+ .then(|| name.to_owned()))
+}
+
+pub fn reset_leftover_database(
+ engine: &Address,
+ root: &Path,
+ secrets: &Secrets,
+ confirmed_volume: &str,
+) -> Result<(), Problem> {
+ if leftover_database_volume(engine, root, secrets)?.as_deref() != Some(confirmed_volume) {
+ return Err(Problem::plain("The leftover database no longer matches the volume you confirmed, or OpenBot could not verify that it owns the volume. Nothing was removed. Try Start again."));
+ }
+ // Never force this operation: the engine must refuse any container attachment, including a
+ // stopped container or one created after inspection. Do not stop containers to make it pass.
+ let removed = engine
+ .command()
+ .current_dir(root)
+ .args(["volume", "rm", confirmed_volume])
+ .output()
+ .map_err(|error| {
+ Problem::with(
+ "OpenBot could not reset the leftover database. Nothing else was removed.",
+ format!("Could not run volume removal: {error}"),
+ )
+ })?;
+ if !removed.status.success() {
+ return Err(Problem::with("OpenBot could not reset the leftover database. It may still be attached to a container. Nothing else was removed; stop the installation using it before trying again.", format!("Volume removal exited with {}. Output omitted because it can contain credentials.", removed.status)));
+ }
+ Ok(())
+}
+
+fn empty_volume_options(options: &serde_json::Value) -> bool {
+ options.is_null()
+ || options
+ .as_object()
+ .is_some_and(|options| options.is_empty())
+}
+
fn postgres_volume_name(configuration: &[u8]) -> Result<String, Problem> {
let config: serde_json::Value = serde_json::from_slice(configuration)
.map_err(|_| postgres_volume_problem("Compose config did not return valid JSON."))?;
+ postgres_data_volume(&config)
+ .and_then(|(_, definition)| definition["name"].as_str())
+ .filter(|name| !name.trim().is_empty())
+ .map(str::to_owned)
+ .ok_or_else(|| {
+ postgres_volume_problem("Compose did not resolve a named volume for Postgres data.")
+ })
+}
+
+fn postgres_data_volume(config: &serde_json::Value) -> Option<(&str, &serde_json::Value)> {
let postgres = &config["services"]["postgres"];
let data = postgres["environment"]["PGDATA"]
.as_str()
@@ -244,18 +382,59 @@ fn postgres_volume_name(configuration: &[u8]) -> Result<String, Problem> {
})
.max_by_key(|mount| mount["target"].as_str().unwrap().len())
});
- let volume = mount
+ mount
.filter(|mount| mount["type"].as_str() == Some("volume"))
.and_then(|mount| mount["source"].as_str())
- .and_then(|source| config["volumes"][source]["name"].as_str())
- .filter(|name| !name.trim().is_empty());
- volume.map(str::to_owned).ok_or_else(|| {
- postgres_volume_problem("Compose did not resolve a named volume for Postgres data.")
- })
+ .and_then(|source| {
+ config["volumes"]
+ .get(source)
+ .map(|definition| (source, definition))
+ })
}
const MACOS_PODMAN_PORTS_FILE: &str = ".openbot-macos-podman.yml";
const MACOS_PODMAN_PORTS: &str = include_str!("macos-podman-ports.yml");
+const HARNESS_PORT_FILE: &str = ".openbot-harness-port.yml";
+
+fn harness_port_overlay(root: &Path, ipv4_only: bool) -> Result<Option<String>, Problem> {
+ let values = crate::env::read_already_set(
+ &root.join(".env"),
+ &["PICKED_HARNESS_HOST_PORT", "PICKED_HARNESS_PORT"],
+ )
+ .map_err(|error| {
+ Problem::with(
+ "OpenBot could not read the Bot's local port.",
+ error.to_string(),
+ )
+ })?;
+ let Some(host) = values.get("PICKED_HARNESS_HOST_PORT") else {
+ return Ok(None);
+ };
+ let parse = |value: &str| {
+ value
+ .parse::<u16>()
+ .ok()
+ .filter(|port| *port != 0)
+ .ok_or_else(|| {
+ Problem::plain("The Bot's local port setting is invalid. Try Start again.")
+ })
+ };
+ let host = parse(host)?;
+ let target = parse(
+ values
+ .get("PICKED_HARNESS_PORT")
+ .map(String::as_str)
+ .unwrap_or("4202"),
+ )?;
+ if host == target {
+ return Ok(None);
+ }
+ let mut overlay = format!("services:\n agent-harness:\n ports: !override\n - \"127.0.0.1:{host}:{target}\"\n");
+ if !ipv4_only {
+ overlay.push_str(&format!(" - \"[::1]:{host}:{target}\"\n"));
+ }
+ Ok(Some(overlay))
+}
/// Only service creation needs the Mac Podman port overlay. In particular, `run migrate` can
/// create its Postgres dependency, so it must use the same configuration as `up`.
@@ -266,7 +445,9 @@ fn compose_start_command(
os: &str,
) -> Result<Command, Problem> {
let mut command = compose_command(engine, root, secrets);
- if os != "macos" || engine.engine != crate::engine::Engine::Podman {
+ let macos_podman = os == "macos" && engine.engine == crate::engine::Engine::Podman;
+ let harness_ports = harness_port_overlay(root, macos_podman)?;
+ if !macos_podman && harness_ports.is_none() {
return Ok(command);
}
@@ -291,19 +472,29 @@ fn compose_start_command(
let environment = String::from_utf8(environment.stdout)
.map_err(|_| Problem::plain("Compose returned unreadable deployment settings."))?;
let files = compose_files(root, &environment)?;
- let overlay = root.join(MACOS_PODMAN_PORTS_FILE);
- if std::fs::read(&overlay).ok().as_deref() != Some(MACOS_PODMAN_PORTS.as_bytes()) {
- std::fs::write(&overlay, MACOS_PODMAN_PORTS).map_err(|error| {
- Problem::with(
- "OpenBot could not prepare the Mac Podman port settings.",
- error.to_string(),
- )
- })?;
- }
for file in files {
command.arg("-f").arg(file);
}
- command.arg("-f").arg(MACOS_PODMAN_PORTS_FILE);
+ for (file, contents) in [
+ (
+ MACOS_PODMAN_PORTS_FILE,
+ macos_podman.then_some(MACOS_PODMAN_PORTS),
+ ),
+ (HARNESS_PORT_FILE, harness_ports.as_deref()),
+ ] {
+ if let Some(contents) = contents {
+ let overlay = root.join(file);
+ if std::fs::read(&overlay).ok().as_deref() != Some(contents.as_bytes()) {
+ std::fs::write(&overlay, contents).map_err(|error| {
+ Problem::with(
+ "OpenBot could not prepare its local port settings.",
+ error.to_string(),
+ )
+ })?;
+ }
+ command.arg("-f").arg(file);
+ }
+ }
Ok(command)
}
@@ -317,7 +508,7 @@ fn compose_files(root: &Path, environment: &str) -> Result<Vec<String>, Problem>
if let Some(files) = setting("COMPOSE_FILE") {
let separator = setting("COMPOSE_PATH_SEPARATOR")
.filter(|value| !value.is_empty())
- .unwrap_or(":"); // Only used on macOS.
+ .unwrap_or(if cfg!(windows) { ";" } else { ":" });
return Ok(files.split(separator).map(str::to_owned).collect());
}
@@ -959,6 +1150,11 @@ pub fn spawn_host_process(
* fought with.
*/
configure_host_process_env(&mut command, process.name, secrets);
+ let ports = crate::env::Ports::read(root)?;
+ command.envs(ports.settings());
+ if process.name == "server" {
+ command.env("PORT", ports.server.to_string());
+ }
if process.script.is_empty() {
command.args(["run", process.package_script]);
} else {
@@ -2531,8 +2727,7 @@ pub fn port_already_taken_except(
}
if something_answers(*port) {
return Some(format!(
- "Something is already listening on port {port}, which OpenBot uses for the {name}. \
- Stop it, or change the port, and start again."
+ "Port {port} for the {name} became unavailable. Try Start again so OpenBot can choose another local port."
));
}
}
@@ -2638,23 +2833,71 @@ pub fn wait_until_answering(
))
}
-/// The last few lines of a process's log, which is where the reason is.
+/// The last build error can precede Bun's wrapper stack, version, and exit message.
+/// Bound both the file read and displayed lines while preserving that useful context.
fn tail_of(logs: &Path, name: &str) -> String {
- let Ok(text) = std::fs::read_to_string(logs.join(format!("{name}.log"))) else {
- return format!("Nothing was written to {name}.log.");
+ use std::io::{Read, Seek, SeekFrom};
+ const MAX_BYTES: u64 = 8 * 1024;
+ let read = || -> std::io::Result<Vec<u8>> {
+ let mut file = std::fs::File::open(logs.join(format!("{name}.log")))?;
+ let offset = file.metadata()?.len().saturating_sub(MAX_BYTES);
+ file.seek(SeekFrom::Start(offset))?;
+ let mut bytes = Vec::new();
+ file.take(MAX_BYTES).read_to_end(&mut bytes)?;
+ // Do not show a truncated first line, which may include part of a credential.
+ if offset > 0 {
+ let first_line = bytes.iter().position(|byte| *byte == b'\n');
+ bytes.drain(..first_line.map_or(bytes.len(), |index| index + 1));
+ }
+ Ok(bytes)
+ };
+ let bytes = match read() {
+ Ok(bytes) => bytes,
+ Err(error) => return format!("Could not read {name}.log: {error}"),
};
+ let text = String::from_utf8_lossy(&bytes);
let tail: Vec<&str> = text
.lines()
.filter(|line| !line.trim().is_empty())
.rev()
- .take(3)
+ .take(40)
.collect();
if tail.is_empty() {
- return format!("{name}.log is empty.");
+ return format!("No complete lines were available in the tail of {name}.log.");
}
let mut lines = tail;
lines.reverse();
- format!("Last from {name}.log: {}", lines.join(" / "))
+ format!(
+ "Last from {name}.log (up to 40 lines, 8 KiB):\n{}",
+ lines.join("\n")
+ )
+}
+
+/// Keep a short startup headline and useful local diagnostics, with credentials removed.
+pub fn startup_problem(problem: Problem, secrets: &Secrets) -> Problem {
+ let database_reset = problem.database_reset;
+ let mut detail = problem.said;
+ if let Some(cleanup) = problem.detail {
+ detail.push('\n');
+ detail.push_str(&cleanup);
+ }
+ let mut credentials: Vec<_> = secrets
+ .iter()
+ .filter(|(key, value)| {
+ !value.is_empty()
+ && (crate::vault::is_secret(key) || key.as_str() == "OPENBOT_DESKTOP_HOST_TOKEN")
+ })
+ .collect();
+ credentials.sort_by_key(|(_, value)| std::cmp::Reverse(value.len()));
+ for (key, value) in credentials {
+ detail = detail.replace(value, &format!("<{key}>"));
+ }
+ let mut problem = Problem::with(
+ "OpenBot could not finish starting. Try Start again, or share the details below for help.",
+ detail,
+ );
+ problem.database_reset = database_reset;
+ problem
}
/// What a directory has to contain before it can be raised.
@@ -2770,6 +3013,60 @@ mod tests {
use super::*;
use crate::test_support::temp_root;
+ #[test]
+ fn startup_log_tail_retains_build_error_before_wrapper_without_loading_whole_log() {
+ let root = temp_root("startup-build-diagnostic");
+ std::fs::create_dir_all(&root).unwrap();
+ let mut log = "old output must be omitted\n".repeat(1_000);
+ log.push_str("error during build: Could not resolve imported module\n");
+ log.push_str(&" at synthetic build frame\n".repeat(20));
+ log.push_str(" at run (app/scripts/serve-or-build.ts:36:11)\n");
+ log.push_str("Bun v1.2.15 (macOS arm64)\nerror: script serve exited with code 1\n");
+ std::fs::write(root.join("app.log"), log).unwrap();
+
+ let detail = tail_of(&root, "app");
+ assert!(
+ detail.contains("Could not resolve imported module"),
+ "{detail}"
+ );
+ assert!(detail.contains("serve-or-build.ts:36:11"), "{detail}");
+ assert!(!detail.contains(&"old output must be omitted\n".repeat(20)));
+ assert!(detail.len() < 8_500, "unbounded startup diagnostic");
+ assert!(detail.lines().count() <= 42, "too many startup log lines");
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
+ #[test]
+ fn startup_problem_keeps_build_and_cleanup_details_but_removes_credentials() {
+ let secrets = Secrets::from([
+ ("OPENAI_API_KEY".into(), "synthetic+key.long".into()),
+ (
+ "OPENBOT_DESKTOP_HOST_TOKEN".into(),
+ "synthetic-host-token".into(),
+ ),
+ ("APP_PORT".into(), "4567".into()),
+ ]);
+ let mut original = Problem::with(
+ "app stopped: Could not resolve imported module; key=synthetic+key.long",
+ "cleanup failed: port 4567 token=synthetic-host-token",
+ );
+ original.database_reset = Some("openbot_postgres-data".into());
+ let problem = startup_problem(original, &secrets);
+ assert_eq!(
+ problem.database_reset.as_deref(),
+ Some("openbot_postgres-data")
+ );
+ assert!(problem.said.len() < 120);
+ assert!(!problem.said.contains("Could not resolve"));
+ let detail = problem.detail.unwrap();
+ assert!(detail.contains("Could not resolve imported module"));
+ assert!(detail.contains("cleanup failed: port 4567"));
+ assert!(detail.contains("<OPENAI_API_KEY>"));
+ assert!(detail.contains("<OPENBOT_DESKTOP_HOST_TOKEN>"));
+ assert!(!detail.contains("synthetic+key.long"));
+ assert!(!detail.contains("synthetic-host-token"));
+ }
+
fn postgres_config_fixture(name: &str) -> serde_json::Value {
serde_json::json!({
"services": {"postgres": {"volumes": [{
@@ -2878,6 +3175,188 @@ mod tests {
}
}
+ fn leftover_database_fixture(root: &Path) -> serde_json::Value {
+ let mut config = postgres_config_fixture("openbot_postgres-data");
+ config["name"] = "openbot".into();
+ std::fs::write(root.join(".fixture-config"), config.to_string()).unwrap();
+ std::fs::write(
+ root.join(".fixture-volumes"),
+ "unrelated\nopenbot_postgres-data\n",
+ )
+ .unwrap();
+ std::fs::write(root.join(".fixture-inspect"), serde_json::json!([{
+ "Name": "openbot_postgres-data", "Driver": "local", "Options": {},
+ "Labels": {"com.docker.compose.project":"openbot", "com.docker.compose.volume":"postgres-data"}
+ }]).to_string()).unwrap();
+ config
+ }
+
+ #[test]
+ fn leftover_database_reset_uses_only_confirmed_compose_owned_volume() {
+ if crate::test_support::isolated_process(
+ "stack::tests::leftover_database_reset_uses_only_confirmed_compose_owned_volume",
+ ) {
+ return;
+ }
+ let path = PathFixture::with_fake_engine("postgres-volume");
+ for address in computer_stop_addresses(&path) {
+ let root = path.bin.join(format!("{}-reset", address.engine.binary()));
+ std::fs::create_dir(&root).unwrap();
+ let record = root.join("commands.log");
+ std::env::set_var("OPENBOT_TEST_ENGINE_RECORD", &record);
+ leftover_database_fixture(&root);
+ assert_eq!(
+ leftover_database_volume(&address, &root, &Secrets::new()).unwrap(),
+ Some("openbot_postgres-data".into())
+ );
+ assert!(
+ reset_leftover_database(&address, &root, &Secrets::new(), "unrelated").is_err()
+ );
+ assert!(!std::fs::read_to_string(&record)
+ .unwrap()
+ .contains("volume rm"));
+ reset_leftover_database(&address, &root, &Secrets::new(), "openbot_postgres-data")
+ .unwrap();
+ assert_eq!(
+ std::fs::read_to_string(root.join(".fixture-volumes")).unwrap(),
+ "unrelated\n"
+ );
+ let log = std::fs::read_to_string(&record).unwrap();
+ let removals: Vec<_> = log
+ .lines()
+ .filter(|line| line.contains("volume rm"))
+ .collect();
+ assert_eq!(removals.len(), 1);
+ assert!(removals[0].ends_with("volume rm openbot_postgres-data"));
+ assert!(!log.contains("--force") && !log.contains("prune") && !log.contains("down"));
+ if address.engine == crate::engine::Engine::Podman {
+ assert!(log.lines().all(|line| line
+ .split_once('\t')
+ .unwrap()
+ .1
+ .starts_with("--connection fixture-machine ")));
+ }
+ }
+ }
+
+ #[test]
+ fn leftover_database_reset_refuses_shared_unowned_changed_or_attached_volumes() {
+ if crate::test_support::isolated_process(
+ "stack::tests::leftover_database_reset_refuses_shared_unowned_changed_or_attached_volumes",
+ ) { return; }
+ let path = PathFixture::with_fake_engine("postgres-volume");
+ let address = computer_stop_addresses(&path)[1].clone();
+ let root = path.bin.join("reset-refusals");
+ std::fs::create_dir(&root).unwrap();
+ let record = root.join("commands.log");
+ std::env::set_var("OPENBOT_TEST_ENGINE_RECORD", &record);
+ for scenario in [
+ "external",
+ "custom-name",
+ "driver",
+ "driver-options",
+ "shared-service",
+ "shared-alias",
+ "foreign-label",
+ "missing-label",
+ "prefix-inspect",
+ "missing",
+ "config-failure",
+ "inventory-failure",
+ "inspect-failure",
+ "attached",
+ ] {
+ let mut config = leftover_database_fixture(&root);
+ std::fs::write(&record, "").unwrap();
+ let marker = match scenario {
+ "external" => {
+ config["volumes"]["postgres-data"]["external"] = true.into();
+ None
+ }
+ "custom-name" => {
+ config["volumes"]["postgres-data"]["name"] = "shared-database".into();
+ None
+ }
+ "driver" => {
+ config["volumes"]["postgres-data"]["driver"] = "nfs".into();
+ None
+ }
+ "driver-options" => {
+ config["volumes"]["postgres-data"]["driver_opts"] =
+ serde_json::json!({"device":"/shared"});
+ None
+ }
+ "shared-service" => {
+ config["services"]["other"] = config["services"]["postgres"].clone();
+ None
+ }
+ "shared-alias" => {
+ config["services"]["other"] = config["services"]["postgres"].clone();
+ config["services"]["other"]["volumes"][0]["source"] = "backup-alias".into();
+ config["volumes"]["backup-alias"] =
+ serde_json::json!({"name": "openbot_postgres-data"});
+ None
+ }
+ "foreign-label" | "missing-label" | "prefix-inspect" => {
+ let mut inspect: serde_json::Value = serde_json::from_str(
+ &std::fs::read_to_string(root.join(".fixture-inspect")).unwrap(),
+ )
+ .unwrap();
+ if scenario == "foreign-label" {
+ inspect[0]["Labels"]["com.docker.compose.project"] =
+ "another-project".into();
+ }
+ if scenario == "missing-label" {
+ inspect[0]["Labels"] = serde_json::json!({});
+ }
+ if scenario == "prefix-inspect" {
+ inspect[0]["Name"] = "openbot_postgres-data-backup".into();
+ }
+ std::fs::write(root.join(".fixture-inspect"), inspect.to_string()).unwrap();
+ None
+ }
+ "missing" => {
+ std::fs::write(root.join(".fixture-volumes"), "unrelated\n").unwrap();
+ None
+ }
+ "config-failure" => Some(".fixture-config-failure"),
+ "inventory-failure" => Some(".fixture-volume-failure"),
+ "inspect-failure" => Some(".fixture-inspect-failure"),
+ "attached" => Some(".fixture-attached"),
+ _ => unreachable!(),
+ };
+ std::fs::write(root.join(".fixture-config"), config.to_string()).unwrap();
+ if let Some(marker) = marker {
+ std::fs::write(root.join(marker), "").unwrap();
+ }
+ let error =
+ reset_leftover_database(&address, &root, &Secrets::new(), "openbot_postgres-data")
+ .expect_err(scenario);
+ assert!(
+ !format!("{error:?}").contains("synthetic-secret"),
+ "{scenario}"
+ );
+ let log = std::fs::read_to_string(&record).unwrap();
+ assert_eq!(
+ log.contains("volume rm"),
+ scenario == "attached",
+ "{scenario}: {log}"
+ );
+ assert!(!log.contains("--force"));
+ assert!(std::fs::read_to_string(root.join(".fixture-volumes"))
+ .unwrap()
+ .contains("unrelated"));
+ if scenario == "attached" {
+ assert!(std::fs::read_to_string(root.join(".fixture-volumes"))
+ .unwrap()
+ .contains("openbot_postgres-data"));
+ }
+ if let Some(marker) = marker {
+ std::fs::remove_file(root.join(marker)).unwrap();
+ }
+ }
+ }
+
#[test]
fn desktop_approval_transport_credential_reaches_only_the_server() {
let secrets = Secrets::from([
@@ -2900,6 +3379,58 @@ mod tests {
}
}
+ #[test]
+ fn host_processes_receive_persisted_ports_on_start_and_restart() {
+ let root = temp_root("host-selected-ports");
+ std::fs::create_dir_all(&root).unwrap();
+ let source = root.join("ports.rs");
+ let bun = root.join(format!("ports{}", std::env::consts::EXE_SUFFIX));
+ std::fs::write(
+ &source,
+ r#"
+fn main() {
+ let role = std::env::current_dir().unwrap().file_name().unwrap().to_string_lossy().into_owned();
+ assert_eq!(std::env::var("APP_PORT").unwrap(), "52110");
+ assert_eq!(std::env::var("SERVER_PORT").unwrap(), "52101");
+ if role == "server" { assert_eq!(std::env::var("PORT").unwrap(), "52101"); }
+}
+"#,
+ )
+ .unwrap();
+ crate::test_support::compile_fixture(&source, &bun);
+ let ports = crate::env::Ports {
+ app: 52110,
+ server: 52101,
+ ..Default::default()
+ };
+ crate::env::write(
+ &root.join(".env"),
+ &ports.settings(),
+ &std::collections::BTreeMap::new(),
+ )
+ .unwrap();
+ let stale = Secrets::from([
+ ("SERVER_PORT".into(), "3001".into()),
+ ("APP_PORT".into(), "3010".into()),
+ ("PORT".into(), "3001".into()),
+ ]);
+ for _ in 0..2 {
+ for process in HOST_PROCESSES {
+ std::fs::create_dir_all(root.join(process.cwd)).unwrap();
+ let status = spawn_host_process(&process, &root, &root.join(".logs"), &bun, &stale)
+ .unwrap()
+ .wait()
+ .unwrap();
+ assert!(
+ status.success(),
+ "{} did not receive selected ports",
+ process.name
+ );
+ }
+ }
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
#[cfg(unix)]
fn unix_fixture(pid: u32, parent: u32) -> UnixProcess {
UnixProcess {
@@ -4214,6 +4745,17 @@ fn main() {
(".fixture-config", ".fixture-config-failure")
} else if actual == ["volume", "ls", "--format", "{{.Name}}"] {
(".fixture-volumes", ".fixture-volume-failure")
+ } else if actual == ["volume", "inspect", "openbot_postgres-data"] {
+ (".fixture-inspect", ".fixture-inspect-failure")
+ } else if actual == ["volume", "rm", "openbot_postgres-data"] {
+ if std::path::Path::new(".fixture-attached").exists() {
+ eprintln!("synthetic-secret attached container");
+ std::process::exit(2);
+ }
+ let inventory = std::fs::read_to_string(".fixture-volumes").unwrap();
+ let remaining: String = inventory.lines().filter(|name| *name != "openbot_postgres-data").map(|name| format!("{name}\n")).collect();
+ std::fs::write(".fixture-volumes", remaining).unwrap();
+ return;
} else { panic!("unexpected volume probe command: {actual:?}"); };
if std::path::Path::new(failure).exists() {
eprintln!("synthetic-secret-must-not-appear-in-diagnostics");
@@ -6372,7 +6914,11 @@ fn main() {
["compose.yaml", "compose.override.yml"]
);
assert_eq!(
- compose_files(&root, "COMPOSE_FILE=first.yml:folder/custom file.yml\n").unwrap(),
+ compose_files(
+ &root,
+ "COMPOSE_FILE=first.yml:folder/custom file.yml\nCOMPOSE_PATH_SEPARATOR=:\n"
+ )
+ .unwrap(),
["first.yml", "folder/custom file.yml"]
);
assert_eq!(
@@ -6386,6 +6932,82 @@ fn main() {
std::fs::remove_dir_all(root).unwrap();
}
+ #[test]
+ fn dynamic_harness_overlay_keeps_container_port_and_loopback_policy() {
+ let root = temp_root("dynamic-harness-port");
+ std::fs::create_dir_all(&root).unwrap();
+ assert!(harness_port_overlay(&root, false).unwrap().is_none());
+ std::fs::write(
+ root.join(".env"),
+ "PICKED_HARNESS_PORT=4206\nPICKED_HARNESS_HOST_PORT=52106\n",
+ )
+ .unwrap();
+ let dual = harness_port_overlay(&root, false).unwrap().unwrap();
+ assert!(dual.contains("ports: !override"));
+ assert!(dual.contains("127.0.0.1:52106:4206"));
+ assert!(dual.contains("[::1]:52106:4206"));
+ let mac_podman = harness_port_overlay(&root, true).unwrap().unwrap();
+ assert!(mac_podman.contains("127.0.0.1:52106:4206"));
+ assert!(!mac_podman.contains("[::1]"));
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
+ #[test]
+ #[ignore = "requires Docker Compose; configuration only, no running engine needed"]
+ fn dynamic_harness_port_is_applied_by_real_compose_without_changing_container_ports() {
+ let root = temp_root("dynamic-harness-compose");
+ std::fs::create_dir_all(&root).unwrap();
+ let source = include_str!("../../../docker-compose.yml");
+ std::fs::write(root.join("docker-compose.yml"), source).unwrap();
+ std::fs::write(
+ root.join("docker-compose.override.yml"),
+ "services:\n agent-harness:\n labels:\n regression: preserved\n",
+ )
+ .unwrap();
+ std::fs::write(root.join(".env"), "PICKED_HARNESS_IMAGE=synthetic:local\nPICKED_HARNESS_PORT=4206\nPICKED_HARNESS_HOST_PORT=52106\nPOSTGRES_PORT=55432\n").unwrap();
+ let command = compose_start_command(
+ &Address::new(crate::engine::Engine::Docker, None),
+ &root,
+ &Secrets::new(),
+ "windows",
+ )
+ .unwrap();
+ let output = {
+ let mut command = command;
+ command
+ .args(["--profile", "*", "config", "--format", "json"])
+ .output()
+ .unwrap()
+ };
+ assert!(
+ output.status.success(),
+ "{}",
+ String::from_utf8_lossy(&output.stderr)
+ );
+ let config: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+ let harness = &config["services"]["agent-harness"];
+ assert_eq!(harness["labels"]["regression"], "preserved");
+ let ports = harness["ports"].as_array().unwrap();
+ assert_eq!(ports.len(), 2);
+ for port in ports {
+ assert_eq!(port["published"], "52106");
+ assert_eq!(port["target"], 4206);
+ assert!(matches!(
+ port["host_ip"].as_str(),
+ Some("127.0.0.1" | "::1")
+ ));
+ }
+ for port in config["services"]["postgres"]["ports"].as_array().unwrap() {
+ assert_eq!(port["published"], "55432");
+ assert_eq!(port["target"], 5432);
+ }
+ assert_eq!(
+ std::fs::read_to_string(root.join("docker-compose.yml")).unwrap(),
+ source
+ );
+ std::fs::remove_dir_all(root).unwrap();
+ }
+
/// Real Compose merging is the important assertion: without !override, IPv6 ports survive.
/// This only reads configuration; it never contacts a container engine or registry.
#[test]
diff --git a/desktop/src-tauri/test-fixtures/provider-oauth-lock-owner.rs b/desktop/src-tauri/test-fixtures/provider-oauth-lock-owner.rs
new file mode 100644
index 00000000..f213fcfd
--- /dev/null
+++ b/desktop/src-tauri/test-fixtures/provider-oauth-lock-owner.rs
@@ -0,0 +1,12 @@
+// Standalone Windows proof: rustc --edition 2021 provider-oauth-lock-owner.rs
+// Unix integration uses the Cargo test binary so libc is supplied by the package.
+#[path = "../src/provider_oauth_lock.rs"]
+mod credential_lock;
+use std::io::{self, Write};
+fn main() {
+ let path = std::env::args_os().nth(1).expect("credential path");
+ let _lock = credential_lock::acquire(std::path::Path::new(&path)).unwrap();
+ println!("locked");
+ io::stdout().flush().unwrap();
+ io::stdin().read_line(&mut String::new()).unwrap();
+}
diff --git a/desktop/src/App.test.tsx b/desktop/src/App.test.tsx
index 81f8f73e..8d7e16f4 100644
--- a/desktop/src/App.test.tsx
+++ b/desktop/src/App.test.tsx
@@ -6,11 +6,19 @@ import {
fireEvent,
render,
waitFor,
+ within,
} from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { StrictMode } from "react";
type Invoke = (command: string, args?: unknown) => Promise<unknown>;
+type ProgressEvent = {
+ step: string;
+ ok: boolean;
+ detail: string;
+ running?: boolean;
+ downloadBytes?: number;
+};
type Deferred<T> = {
promise: Promise<T>;
resolve: (value: T) => void;
@@ -22,7 +30,7 @@ let invokeHandler: Invoke = async () => {
throw new Error("invoke handler was not installed");
};
const progressListeners = new Set<
- (event: { payload: { step: string; ok: boolean; detail: string } }) => void
+ (event: { payload: ProgressEvent }) => void
>();
mock.module("@tauri-apps/api/core", () => ({
@@ -35,9 +43,7 @@ mock.module("@tauri-apps/api/core", () => ({
mock.module("@tauri-apps/api/event", () => ({
listen: async (
name: string,
- listener: (event: {
- payload: { step: string; ok: boolean; detail: string };
- }) => void,
+ listener: (event: { payload: ProgressEvent }) => void,
) => {
if (name === "setup:progress") progressListeners.add(listener);
return () => progressListeners.delete(listener);
@@ -102,8 +108,196 @@ function installationCalls() {
);
}
+async function beginPendingInstallation() {
+ setupRootConfiguration("/tmp/install-progress", async () =>
+ emptyConfiguration(),
+ );
+ let preparation = deferred<void>();
+ const previous = invokeHandler;
+ invokeHandler = async (command, args) =>
+ command === "prepare_installation"
+ ? preparation.promise
+ : previous(command, args);
+ const view = await renderApp();
+ await enterInstallation(view);
+ await userEvent.click(view.getByRole("button", { name: "Install OpenBot" }));
+ return {
+ view,
+ preparation,
+ retry: async () => {
+ preparation = deferred<void>();
+ await userEvent.click(
+ view.getByRole("button", { name: "Retry installation" }),
+ );
+ return preparation;
+ },
+ };
+}
+
+async function emitProgress(payload: ProgressEvent) {
+ await act(async () => {
+ for (const listener of progressListeners) listener({ payload });
+ });
+}
+
+test("installation shows its active stage immediately and advances elapsed time", async () => {
+ const { view, preparation } = await beginPendingInstallation();
+ const engine = within(
+ view.getByRole("listitem", { name: "Container engine" }),
+ );
+ expect(engine.getByText("Checking the software OpenBot needs.")).toBeTruthy();
+ expect(engine.getByText("In progress")).toBeTruthy();
+ expect(engine.queryByText("✓")).toBeNull();
+ await waitFor(() => expect(engine.getByText(/1s elapsed/)).toBeTruthy(), {
+ timeout: 1800,
+ });
+ await act(async () => preparation.resolve());
+ expect(engine.getByText("Complete")).toBeTruthy();
+ expect(engine.getByText("✓")).toBeTruthy();
+ expect(view.queryByText("In progress") === null).toBe(true);
+ expect(view.queryByText(/elapsed/)).toBeNull();
+});
+
+test("running updates show real download bytes without completing a stage early", async () => {
+ const { view, preparation } = await beginPendingInstallation();
+ await emitProgress({
+ step: "engine",
+ ok: true,
+ detail: "Docker is answering.",
+ });
+ await emitProgress({
+ step: "dependencies",
+ ok: true,
+ running: true,
+ detail: "Downloading the local runtime.",
+ downloadBytes: 2_400_000,
+ });
+ const dependencies = within(
+ view.getByRole("listitem", { name: "Dependencies" }),
+ );
+ expect(dependencies.getByText("In progress")).toBeTruthy();
+ expect(dependencies.getByText(/2.4 MB downloaded/)).toBeTruthy();
+ expect(dependencies.queryByText("✓")).toBeNull();
+ await emitProgress({
+ step: "dependencies",
+ ok: true,
+ running: true,
+ detail: "Downloading the local runtime.",
+ downloadBytes: 5_700_000,
+ });
+ expect(view.getAllByRole("listitem", { name: "Dependencies" })).toHaveLength(
+ 1,
+ );
+ expect(dependencies.getByText(/5.7 MB downloaded/)).toBeTruthy();
+ expect(dependencies.queryByText(/2.4 MB downloaded/)).toBeNull();
+ expect(dependencies.queryByText("Complete")).toBeNull();
+ await emitProgress({
+ step: "dependencies",
+ ok: true,
+ running: false,
+ detail: "Local runtime installed.",
+ });
+ expect(dependencies.getByText("Complete")).toBeTruthy();
+ expect(dependencies.getByText("✓")).toBeTruthy();
+ expect(dependencies.queryByText("In progress")).toBeNull();
+ await emitProgress({
+ step: "images",
+ ok: true,
+ running: true,
+ detail: "Downloading local software (2/4).",
+ });
+ expect(view.getByText("Downloading local software (2/4).")).toBeTruthy();
+ await act(async () => preparation.resolve());
+ expect(view.queryByText("In progress") === null).toBe(true);
+});
+
+test("installation failure stops active indicators and retry begins fresh", async () => {
+ const { view, preparation, retry } = await beginPendingInstallation();
+ await emitProgress({
+ step: "engine",
+ ok: true,
+ running: false,
+ detail: "Docker is answering.",
+ });
+ await emitProgress({
+ step: "dependencies",
+ ok: true,
+ running: true,
+ detail: "Installing the local runtime.",
+ });
+ await act(async () =>
+ preparation.reject({ said: "The download was interrupted." }),
+ );
+ const dependencies = within(
+ view.getByRole("listitem", { name: "Dependencies" }),
+ );
+ expect(dependencies.getByText("Failed")).toBeTruthy();
+ expect(dependencies.getByText("✗")).toBeTruthy();
+ expect(dependencies.getByText("The download was interrupted.")).toBeTruthy();
+ expect(view.queryByText("In progress") === null).toBe(true);
+ expect(view.queryByText(/elapsed/)).toBeNull();
+ expect(
+ within(view.getByRole("listitem", { name: "Container engine" })).getByText(
+ "Complete",
+ ),
+ ).toBeTruthy();
+ const secondAttempt = await retry();
+ expect(view.queryByRole("listitem", { name: "Dependencies" })).toBeNull();
+ expect(view.queryByText("Failed")).toBeNull();
+ expect(view.getByText("In progress")).toBeTruthy();
+ expect(view.queryByRole("alert")).toBeNull();
+ await act(async () => secondAttempt.resolve());
+ expect(view.queryByText("In progress") === null).toBe(true);
+ expect(
+ view.getByRole("heading", { name: "Installation complete" }),
+ ).toBeTruthy();
+});
+
+test.each([
+ [false, false],
+ [true, false],
+ [false, true],
+ [true, true],
+])(
+ "startup settles active progress (automatic=%s, succeeds=%s)",
+ async (automatic, succeeds) => {
+ useInterruptedShutdownSetup();
+ const launch = deferred<void>();
+ const previous = invokeHandler;
+ invokeHandler = async (command, args) => {
+ if (command === "last_failure" && automatic) return null;
+ if (command === "start_stack") return launch.promise;
+ return previous(command, args);
+ };
+ const view = await renderApp();
+ if (!automatic)
+ await userEvent.click(
+ view.getByRole("button", { name: "Start OpenBot" }),
+ );
+ await emitProgress({
+ step: "services",
+ ok: true,
+ running: true,
+ detail: "Starting local services.",
+ });
+ expect(view.getByText("In progress")).toBeTruthy();
+ await act(async () => {
+ if (succeeds) launch.resolve();
+ else launch.reject({ said: "Local services could not start." });
+ });
+ expect(view.queryByText("In progress") === null).toBe(true);
+ const services = within(view.getByRole("listitem", { name: "Containers" }));
+ expect(services.getByText(succeeds ? "Complete" : "Failed")).toBeTruthy();
+ expect(services.getByText(succeeds ? "✓" : "✗")).toBeTruthy();
+ if (!succeeds)
+ expect(
+ view.getByRole("button", { name: "Start OpenBot" }),
+ ).toHaveProperty("disabled", false);
+ },
+);
+
test("installation completes before either sign-in is available", async () => {
- useRootConfigurationSetup("/tmp/install-before-signin", async () =>
+ setupRootConfiguration("/tmp/install-before-signin", async () =>
emptyConfiguration(),
);
const preparation = deferred<void>();
@@ -164,6 +358,11 @@ test("installation completes before either sign-in is available", async () => {
expect(
view.getByRole("heading", { name: "Installation complete" }),
).toBeTruthy();
+ expect(
+ view
+ .getByRole("button", { name: "Repair installation" })
+ .closest("details"),
+ ).toHaveProperty("open", false);
expect(view.queryByRole("heading", { name: "Connect your AI" })).toBeNull();
await userEvent.click(
view.getByRole("button", { name: "Continue to sign in" }),
@@ -171,8 +370,73 @@ test("installation completes before either sign-in is available", async () => {
expect(view.getByRole("heading", { name: "Connect your AI" })).toBeTruthy();
});
+test("CopilotKit Back preserves the selected AI and connection settings", async () => {
+ setupRootConfiguration("/tmp/back-preserves-setup", async () =>
+ emptyConfiguration(),
+ );
+ const view = await renderApp();
+ const user = userEvent.setup({ document: view.container.ownerDocument });
+ await enterInstallation(view);
+ await completeInstallation(view);
+ await userEvent.click(await view.findByRole("radio", { name: /OpenAI/ }));
+ await userEvent.type(view.getByLabelText("OpenAI API key"), "model-test-key");
+ await userEvent.click(view.getByRole("button", { name: "Continue" }));
+ await userEvent.click(
+ view.getByText("Point at your own Intelligence server"),
+ );
+ await userEvent.type(view.getByLabelText("Project key"), "project-test-key");
+ const api = view.getByLabelText("API URL");
+ await user.clear(api);
+ await user.type(api, "https://intelligence.example/api");
+ const gateway = view.getByLabelText("Gateway WebSocket URL");
+ await user.clear(gateway);
+ await user.type(gateway, "wss://intelligence.example/ws");
+ await userEvent.click(view.getByRole("button", { name: "Back" }));
+ expect(view.getByRole("heading", { name: "Connect your AI" })).toBeTruthy();
+ expect(view.getByRole("radio", { name: /OpenAI/ })).toHaveProperty(
+ "checked",
+ true,
+ );
+ expect(view.getByLabelText("OpenAI API key")).toHaveProperty(
+ "value",
+ "model-test-key",
+ );
+ await userEvent.click(view.getByRole("button", { name: "Continue" }));
+ expect(
+ view.getByRole("heading", { name: "Connect to CopilotKit" }),
+ ).toBeTruthy();
+ await userEvent.click(
+ view.getByText("Point at your own Intelligence server"),
+ );
+ expect(view.getByLabelText("Project key")).toHaveProperty(
+ "value",
+ "project-test-key",
+ );
+ expect(view.getByLabelText("API URL")).toHaveProperty(
+ "value",
+ "https://intelligence.example/api",
+ );
+ expect(view.getByLabelText("Gateway WebSocket URL")).toHaveProperty(
+ "value",
+ "wss://intelligence.example/ws",
+ );
+ expect(view.getByRole("button", { name: "Start OpenBot" })).toHaveProperty(
+ "disabled",
+ false,
+ );
+ expect(
+ view.queryByRole("button", { name: "Change AI connection" }) === null,
+ ).toBe(true);
+ expect(
+ view
+ .getByRole("button", { name: "Change installation" })
+ .closest("details"),
+ ).toHaveProperty("open", false);
+ expect(installationCalls()).toHaveLength(1);
+});
+
test("failed installation blocks sign-in and retries before reporting completion", async () => {
- useRootConfigurationSetup("/tmp/install-retry", async () =>
+ setupRootConfiguration("/tmp/install-retry", async () =>
emptyConfiguration(),
);
const previous = invokeHandler;
@@ -211,7 +475,7 @@ test("failed installation blocks sign-in and retries before reporting completion
});
test("provider sign-in retries and Back reuse the completed local installation", async () => {
- useRootConfigurationSetup("/tmp/provider-retry", async () =>
+ setupRootConfiguration("/tmp/provider-retry", async () =>
emptyConfiguration(),
);
const previous = invokeHandler;
@@ -260,7 +524,7 @@ test("provider sign-in retries and Back reuse the completed local installation",
});
test("a completed installation can be repaired after a provider reports missing assets", async () => {
- useRootConfigurationSetup("/tmp/repair-installation", async () =>
+ setupRootConfiguration("/tmp/repair-installation", async () =>
emptyConfiguration(),
);
const previous = invokeHandler;
@@ -293,6 +557,7 @@ test("a completed installation can be repaired after a provider reports missing
);
await view.findByText("Return to Install and try again.");
await userEvent.click(view.getByRole("button", { name: "Back" }));
+ await userEvent.click(view.getByText("Installation options"));
await userEvent.click(
view.getByRole("button", { name: "Repair installation" }),
);
@@ -345,7 +610,7 @@ test.each([false, true])(
"reopening a successful setup starts its saved root and connections without the wizard or Ask (Strict Mode=%s)",
async (strictMode) => {
const root = "/tmp/successful-setup-root";
- useRootConfigurationSetup("/tmp/default-root", async () => ({
+ setupRootConfiguration("/tmp/default-root", async () => ({
values: {
INTELLIGENCE_API_URL: "https://own.example/api",
INTELLIGENCE_GATEWAY_WS_URL: "wss://own.example/ws",
@@ -397,7 +662,7 @@ test.each([false, true])(
);
test("a failed automatic reopen offers recovery without retrying or installing", async () => {
- useRootConfigurationSetup("/tmp/reopen-failure", async () => ({
+ setupRootConfiguration("/tmp/reopen-failure", async () => ({
...savedOpenAiConfiguration(),
saved: { ...savedOpenAiConfiguration().saved, model: "open-ai-api-key" },
launch: { harness: { id: "langgraph" } },
@@ -428,7 +693,7 @@ test("a failed automatic reopen offers recovery without retrying or installing",
test("menu Stop retains the installed root for explicit Start without the wizard", async () => {
const root = "/tmp/menu-stopped-installation";
- useRootConfigurationSetup(root, async () => ({
+ setupRootConfiguration(root, async () => ({
...savedOpenAiConfiguration(),
saved: { ...savedOpenAiConfiguration().saved, model: "open-ai-api-key" },
launch: { harness: { id: "mastra" } },
@@ -457,7 +722,7 @@ test("menu Stop retains the installed root for explicit Start without the wizard
});
test("completed local installation resumes at sign-in when it has never launched", async () => {
- useRootConfigurationSetup("/tmp/installed-before-signin", async () => ({
+ setupRootConfiguration("/tmp/installed-before-signin", async () => ({
...emptyConfiguration(),
installation: { harness: { id: "mastra" } },
}));
@@ -507,7 +772,7 @@ test.each(["reopen", "runtime"])(
async (source) => {
const root = "/tmp/organization-installation";
const authorityUrl = "https://company.example";
- useRootConfigurationSetup(root, async () => ({
+ setupRootConfiguration(root, async () => ({
...savedOpenAiConfiguration(),
values: { OPENBOT_ORGANIZATION_AUTH_URL: authorityUrl },
saved: { ...savedOpenAiConfiguration().saved, model: "open-ai-api-key" },
@@ -578,7 +843,7 @@ test.each(["model", "intelligence"])(
"an unavailable saved %s connection opens only its refresh screen and returns to the existing app",
async (connection) => {
const root = "/tmp/installed-refresh";
- useRootConfigurationSetup(root, async () => ({
+ setupRootConfiguration(root, async () => ({
...savedOpenAiConfiguration(),
saved: { ...savedOpenAiConfiguration().saved, model: "open-ai-api-key" },
launch: { harness: { id: "mastra" } },
@@ -654,7 +919,7 @@ test.each(["model", "intelligence"])(
test("reopening a retained root waits for its saved setup without flashing the wizard", async () => {
const root = "/tmp/reopen-pending-configuration";
const configuration = deferred<ReturnType<typeof savedOpenAiConfiguration>>();
- useRootConfigurationSetup(root, async () => configuration.promise);
+ setupRootConfiguration(root, async () => configuration.promise);
const previous = invokeHandler;
invokeHandler = async (command, args) => {
if (command === "selected_root") return root;
@@ -676,7 +941,7 @@ test("reopening a retained root waits for its saved setup without flashing the w
function useInterruptedShutdownSetup() {
const root = "/tmp/interrupted-shutdown-root";
const notice = "OpenBot had trouble shutting down last time.";
- useRootConfigurationSetup("/tmp/default-root", async () => ({
+ setupRootConfiguration("/tmp/default-root", async () => ({
values: {
INTELLIGENCE_API_URL: "https://own.example/api",
INTELLIGENCE_GATEWAY_WS_URL: "wss://own.example/ws",
@@ -786,7 +1051,7 @@ test.each(["model", "root", "Intelligence"])(
test.each(["supervisor", "windows"])(
"automatic reopen respects the existing %s blocker",
async (blocker) => {
- useRootConfigurationSetup("/tmp/reopen-blocked", async () => ({
+ setupRootConfiguration("/tmp/reopen-blocked", async () => ({
...savedOpenAiConfiguration(),
saved: { ...savedOpenAiConfiguration().saved, model: "open-ai-api-key" },
launch: { harness: { id: "langgraph" } },
@@ -822,7 +1087,7 @@ test.each(["supervisor", "windows"])(
);
test("setup records telemetry without a consent gate and deduplicates viewed steps", async () => {
- useRootConfigurationSetup("/tmp/private-setup-root", async () =>
+ setupRootConfiguration("/tmp/private-setup-root", async () =>
emptyConfiguration(),
);
const previous = invokeHandler;
@@ -962,7 +1227,108 @@ function emptyConfiguration() {
};
}
-function useRootConfigurationSetup(
+test("leftover database recovery requires confirmation and keeps setup ready to retry", async () => {
+ useCompatibleEndpointSetup({});
+ const previous = invokeHandler;
+ const reset = deferred<void>();
+ let starts = 0;
+ invokeHandler = async (command, args) => {
+ if (command === "start_stack" && ++starts === 1)
+ throw {
+ said: "A previous OpenBot database remains without its encryption key.",
+ database_reset: "fixture_postgres-data",
+ };
+ if (command === "reset_leftover_database") return reset.promise;
+ return previous(command, args);
+ };
+ const view = await enterCompatibleEndpoint(
+ "https://model.example/v1",
+ "synthetic-key",
+ );
+ await userEvent.click(view.getByRole("button", { name: "Continue" }));
+ await userEvent.click(view.getByRole("button", { name: "Start OpenBot" }));
+ const resets = () =>
+ invokeCalls.filter((call) => call.command === "reset_leftover_database");
+ await userEvent.click(
+ await view.findByRole("button", { name: "Reset leftover database" }),
+ );
+ expect(view.getByText(/permanently deletes/)).toBeTruthy();
+ expect(resets()).toHaveLength(0);
+ await userEvent.click(view.getByRole("button", { name: "Keep saved data" }));
+ expect(resets()).toHaveLength(0);
+ expect(view.queryByRole("button", { name: "Delete saved data" })).toBeNull();
+ await userEvent.click(
+ view.getByRole("button", { name: "Reset leftover database" }),
+ );
+ await userEvent.click(
+ view.getByRole("button", { name: "Delete saved data" }),
+ );
+ expect(resets()).toEqual([
+ {
+ command: "reset_leftover_database",
+ args: {
+ root: "/tmp/openbot-app-test",
+ volume: "fixture_postgres-data",
+ confirmed: true,
+ },
+ },
+ ]);
+ expect(
+ view.getByRole("button", { name: "Deleting saved data…" }),
+ ).toHaveProperty("disabled", true);
+ expect(view.getByRole("button", { name: "Working…" })).toHaveProperty(
+ "disabled",
+ true,
+ );
+ await act(async () => reset.resolve());
+ expect(
+ view.queryByRole("button", { name: "Reset leftover database" }),
+ ).toBeNull();
+ expect(view.queryByRole("alert")).toBeNull();
+ expect(starts).toBe(1);
+ await userEvent.click(view.getByRole("button", { name: "Start OpenBot" }));
+ await view.findByRole("button", { name: "Ask" });
+ expect(installationCalls()).toHaveLength(1);
+});
+
+test("database recovery failure is shown without restarting services", async () => {
+ useCompatibleEndpointSetup({});
+ const previous = invokeHandler;
+ invokeHandler = async (command, args) => {
+ if (command === "start_stack")
+ throw {
+ said: "A previous database remains.",
+ database_reset: "fixture_postgres-data",
+ };
+ if (command === "reset_leftover_database")
+ throw {
+ said: "The database is still in use. Close the other OpenBot installation first.",
+ };
+ return previous(command, args);
+ };
+ const view = await enterCompatibleEndpoint(
+ "https://model.example/v1",
+ "synthetic-key",
+ );
+ await userEvent.click(view.getByRole("button", { name: "Continue" }));
+ await userEvent.click(view.getByRole("button", { name: "Start OpenBot" }));
+ await userEvent.click(
+ await view.findByRole("button", { name: "Reset leftover database" }),
+ );
+ await userEvent.click(
+ view.getByRole("button", { name: "Delete saved data" }),
+ );
+ expect(await view.findByText(/database is still in use/)).toBeTruthy();
+ expect(
+ invokeCalls.filter((call) => call.command === "start_stack"),
+ ).toHaveLength(1);
+ expect(view.getByRole("button", { name: "Start OpenBot" })).toHaveProperty(
+ "disabled",
+ false,
+ );
+});
+
+function setupRootConfiguration(
rootA: string,
loadConfiguration: (root: string) => Promise<unknown>,
) {
@@ -1025,7 +1391,7 @@ function useRootConfigurationSetup(
}
test("Windows detection failure blocks setup and displays its diagnostic", async () => {
- useRootConfigurationSetup("/tmp/openbot-windows-detection-test", async () =>
+ setupRootConfiguration("/tmp/openbot-windows-detection-test", async () =>
emptyConfiguration(),
);
const setupHandler = invokeHandler;
@@ -1054,7 +1420,7 @@ test("Windows detection failure blocks setup and displays its diagnostic", async
});
test("a failed Windows blocker instruction is visible instead of an empty blocker", async () => {
- useRootConfigurationSetup("/tmp/openbot-windows-detection-test", async () =>
+ setupRootConfiguration("/tmp/openbot-windows-detection-test", async () =>
emptyConfiguration(),
);
const setupHandler = invokeHandler;
@@ -1073,7 +1439,7 @@ test("a failed Windows blocker instruction is visible instead of an empty blocke
});
test("a successfully detected missing WSL feature keeps its setup instruction", async () => {
- useRootConfigurationSetup("/tmp/openbot-windows-detection-test", async () =>
+ setupRootConfiguration("/tmp/openbot-windows-detection-test", async () =>
emptyConfiguration(),
);
const setupHandler = invokeHandler;
@@ -1091,7 +1457,7 @@ test("a successfully detected missing WSL feature keeps its setup instruction",
});
test("disabled Virtual Machine Platform displays its feature-specific fix and blocks setup", async () => {
- useRootConfigurationSetup("/tmp/openbot-vmp-detection-test", async () =>
+ setupRootConfiguration("/tmp/openbot-vmp-detection-test", async () =>
emptyConfiguration(),
);
const setupHandler = invokeHandler;
@@ -1564,9 +1930,118 @@ test("empty Intelligence projects keep sign-in retryable while Start waits for a
);
});
+async function enterProjectSelection() {
+ setupRootConfiguration("/tmp/create-project", async () =>
+ emptyConfiguration(),
+ );
+ const previous = invokeHandler;
+ invokeHandler = async (command, args) => {
+ if (command === "begin_intelligence_sign_in")
+ return "https://copilotkit.test/sign-in";
+ if (command === "finish_intelligence_sign_in") return [];
+ if (command === "intelligence_key_for") return "created-project-key";
+ return previous(command, args);
+ };
+ const view = await renderApp();
+ await enterInstallation(view);
+ await completeInstallation(view);
+ await userEvent.click(await view.findByRole("radio", { name: /OpenAI/ }));
+ await userEvent.type(view.getByLabelText("OpenAI API key"), "model-test-key");
+ await userEvent.click(view.getByRole("button", { name: "Continue" }));
+ await userEvent.click(
+ view.getByRole("button", { name: "Sign in to CopilotKit" }),
+ );
+ return view;
+}
+
+test("creating a named project connects it only after the user submits", async () => {
+ const view = await enterProjectSelection();
+ const creation = deferred<{ id: string; name: string }>();
+ const previous = invokeHandler;
+ invokeHandler = async (command, args) =>
+ command === "create_intelligence_project"
+ ? creation.promise
+ : previous(command, args);
+ expect(
+ invokeCalls.some((call) => call.command === "create_intelligence_project"),
+ ).toBe(false);
+ const create = view.getByRole("button", { name: "Create project" });
+ expect(create).toHaveProperty("disabled", true);
+ await userEvent.type(
+ view.getByLabelText("New project name"),
+ " OpenBot workspace ",
+ );
+ await userEvent.click(create);
+ expect(invokeCalls).toContainEqual({
+ command: "create_intelligence_project",
+ args: { name: "OpenBot workspace" },
+ });
+ expect(
+ view.getByRole("button", { name: "Creating project…" }),
+ ).toHaveProperty("disabled", true);
+ expect(view.getByLabelText("New project name")).toHaveProperty(
+ "disabled",
+ true,
+ );
+ await act(async () =>
+ creation.resolve({ id: "new-project", name: "OpenBot workspace" }),
+ );
+ expect(view.getByText("Connected to CopilotKit.")).toBeTruthy();
+ expect(invokeCalls).toContainEqual({
+ command: "intelligence_key_for",
+ args: { project: "new-project" },
+ });
+ expect(view.getByRole("button", { name: "Start OpenBot" })).toHaveProperty(
+ "disabled",
+ false,
+ );
+});
+
+test("project creation failure preserves the name and retries without losing a created project", async () => {
+ const view = await enterProjectSelection();
+ const previous = invokeHandler;
+ let creations = 0;
+ let provisions = 0;
+ invokeHandler = async (command, args) => {
+ if (command === "create_intelligence_project") {
+ if (++creations === 1)
+ throw { said: "The project could not be created." };
+ return { id: "new-project", name: "OpenBot workspace" };
+ }
+ if (command === "intelligence_key_for" && ++provisions === 1)
+ throw { said: "The project key could not be created." };
+ return previous(command, args);
+ };
+ await userEvent.type(
+ view.getByLabelText("New project name"),
+ "OpenBot workspace",
+ );
+ await userEvent.click(view.getByRole("button", { name: "Create project" }));
+ expect(view.getByRole("alert").textContent).toContain(
+ "The project could not be created.",
+ );
+ expect(view.getByLabelText("New project name")).toHaveProperty(
+ "value",
+ "OpenBot workspace",
+ );
+ expect(view.getByRole("button", { name: "Create project" })).toHaveProperty(
+ "disabled",
+ false,
+ );
+ await userEvent.click(view.getByRole("button", { name: "Create project" }));
+ expect(view.getByRole("alert").textContent).toContain(
+ "The project key could not be created.",
+ );
+ await userEvent.click(
+ view.getByRole("button", { name: "OpenBot workspace" }),
+ );
+ expect(view.getByText("Connected to CopilotKit.")).toBeTruthy();
+ expect(creations).toBe(2);
+});
+
test("mount navigates to OpenBot only when the selected root is already owned and running", async () => {
const root = "/tmp/openbot-owned-running-root";
- useRootConfigurationSetup(root, async () => emptyConfiguration());
+ setupRootConfiguration(root, async () => emptyConfiguration());
const setupHandler = invokeHandler;
invokeHandler = async (command, args) => {
if (command === "already_running") {
@@ -1584,7 +2059,7 @@ test("mount navigates to OpenBot only when the selected root is already owned an
test("mount leaves setup visible when the shared port answers without selected root ownership", async () => {
const root = "/tmp/openbot-unowned-running-root";
- useRootConfigurationSetup(root, async () => emptyConfiguration());
+ setupRootConfiguration(root, async () => emptyConfiguration());
const view = await renderApp();
@@ -1598,7 +2073,7 @@ test("mount leaves setup visible when the shared port answers without selected r
for (const staleProbe of [false, true]) {
test(`recovery mount keeps setup available after ${staleProbe ? "a stale positive" : "a negative"} adoption probe`, async () => {
- useRootConfigurationSetup("/tmp/openbot-worker-recovery", async () =>
+ setupRootConfiguration("/tmp/openbot-worker-recovery", async () =>
emptyConfiguration(),
);
const setupHandler = invokeHandler;
@@ -1726,7 +2201,7 @@ test("root edits reload saved configuration for that root and ignore stale saved
const emptyForRootB = deferred<ReturnType<typeof emptyConfiguration>>();
const savedForRootC = deferred<ReturnType<typeof savedOpenAiConfiguration>>();
- useRootConfigurationSetup(rootA, async (requestedRoot) => {
+ setupRootConfiguration(rootA, async (requestedRoot) => {
if (requestedRoot === rootA) return savedForRootA.promise;
if (requestedRoot === rootB) return emptyForRootB.promise;
if (requestedRoot === rootC) return savedForRootC.promise;
@@ -1818,7 +2293,7 @@ test("root edits reload saved configuration for that root and ignore stale saved
test("same-process setup remount prefers the retained selected root", async () => {
const rootA = "/tmp/openbot-default-root";
const rootB = "/tmp/openbot-retained-root";
- useRootConfigurationSetup(rootA, async (requestedRoot) => {
+ setupRootConfiguration(rootA, async (requestedRoot) => {
if (requestedRoot !== rootB)
throw new Error(`unexpected already_configured root ${requestedRoot}`);
return savedOpenAiConfiguration();
@@ -1880,7 +2355,7 @@ test.each([
root: string;
response: Deferred<ReturnType<typeof savedOpenAiConfiguration>>;
}> = [];
- useRootConfigurationSetup(rootA, async (root) => {
+ setupRootConfiguration(rootA, async (root) => {
const response = deferred<ReturnType<typeof savedOpenAiConfiguration>>();
requests.push({ root, response });
return response.promise;
@@ -2337,7 +2812,7 @@ for (const provider of [
async (session) => {
const planToken = `synthetic-${provider.id}-plan-token`;
const hiddenKey = `sk-synthetic-${provider.id}-hidden`;
- useRootConfigurationSetup("/tmp/openbot-app-test", async () => ({
+ setupRootConfiguration("/tmp/openbot-app-test", async () => ({
...emptyConfiguration(),
saved: {
...emptyConfiguration().saved,
@@ -2542,7 +3017,7 @@ for (const provider of [
]) {
for (const login of ["plan", "api-key"] as const) {
test(`unknown legacy ${provider.name} ${login} and Intelligence reuse stays passive until Start`, async () => {
- useRootConfigurationSetup("/tmp/synthetic-legacy-root", async () => ({
+ setupRootConfiguration("/tmp/synthetic-legacy-root", async () => ({
values: {},
saved: {},
}));
@@ -2597,9 +3072,7 @@ for (const provider of [
);
expect(view.queryByText("Connected to CopilotKit.")).toBeNull();
// Returning to the provider screen retains deliberate reuse without signing in automatically.
- await userEvent.click(
- view.getByRole("button", { name: "Change AI connection" }),
- );
+ await userEvent.click(view.getByRole("button", { name: "Back" }));
await userEvent.click(
await view.findByRole("button", { name: "Continue" }),
);
diff --git a/desktop/src/App.tsx b/desktop/src/App.tsx
index 3bdd28e0..04b2b7bf 100644
--- a/desktop/src/App.tsx
+++ b/desktop/src/App.tsx
@@ -2,6 +2,7 @@ import { invoke } from "@tauri-apps/api/core";
import { listen } from "@tauri-apps/api/event";
import { useCallback, useEffect, useRef, useState } from "react";
import { Ask } from "./Ask";
+import { DatabaseReset } from "./DatabaseReset";
import {
DEFAULT_HARNESS,
type HarnessChoice,
@@ -38,7 +39,13 @@ type Blocker =
| "virtualization-disabled"
| "not-administrator";
-type Progress = { step: string; ok: boolean; detail: string };
+type Progress = {
+ step: string;
+ ok: boolean;
+ detail: string;
+ running?: boolean;
+ downloadBytes?: number;
+};
type AlreadyConfigured = {
values: Record<string, string>;
@@ -104,6 +111,8 @@ export function App() {
const [projects, setProjects] = useState<
{ id: string; name: string }[] | null
>(null);
+ const [projectName, setProjectName] = useState("");
+ const [creatingProject, setCreatingProject] = useState(false);
const [signingIn, setSigningIn] = useState(false);
/*
* The address the browser was sent to, kept so the screen can show it.
@@ -148,6 +157,28 @@ export function App() {
setSigningIn(false);
}
}
+ async function createProject() {
+ const name = projectName.trim();
+ if (!name || signingIn) return;
+ setSigningIn(true);
+ setCreatingProject(true);
+ setFailure(null);
+ try {
+ const project = await invoke<{ id: string; name: string }>(
+ "create_intelligence_project",
+ { name },
+ );
+ setProjects((current) => [...(current ?? []), project]);
+ setProjectName("");
+ await pickProject(project.id);
+ } catch (error) {
+ setFailure(asProblem(error));
+ } finally {
+ setSigningIn(false);
+ setCreatingProject(false);
+ }
+ }
+
const [step, setStep] = useState<SetupStep>("welcome");
const [apiUrl, setApiUrl] = useState(MANAGED_INTELLIGENCE_API_URL);
const [wsUrl, setWsUrl] = useState(MANAGED_INTELLIGENCE_GATEWAY_WS_URL);
@@ -196,6 +227,7 @@ export function App() {
const [recoveryFailure, setRecoveryFailure] = useState<Problem | null>(null);
const recoverFromStart = useCallback((error: unknown) => {
const problem = asProblem(error);
+ setSteps((current) => settleProgress(current, problem));
setRecoveryFailure(problem);
if (problem.connection === "model") setStep("model");
if (problem.connection === "intelligence") {
@@ -385,6 +417,7 @@ export function App() {
: {}),
});
if (!active) return;
+ setSteps((current) => settleProgress(current));
setRunning(true);
setRecoveryFailure(null);
await invoke("show_openbot");
@@ -426,14 +459,24 @@ export function App() {
if (busy || !root.trim()) return;
setBusy(true);
setFailure(null);
- setSteps([]);
+ setSteps([
+ {
+ step: "engine",
+ ok: true,
+ running: true,
+ detail: "Checking the software OpenBot needs.",
+ },
+ ]);
setPreparation({ key: installationKey, status: "preparing" });
try {
await invoke("prepare_installation", { root: root.trim(), harness });
+ setSteps((current) => settleProgress(current));
setPreparation({ key: installationKey, status: "complete" });
} catch (error) {
+ const problem = asProblem(error);
+ setSteps((current) => settleProgress(current, problem));
setPreparation({ key: installationKey, status: "failed" });
- setFailure(asProblem(error));
+ setFailure(problem);
} finally {
setBusy(false);
}
@@ -464,6 +507,7 @@ export function App() {
? { organizationAuthUrl: organizationAuthorityUrl }
: {}),
});
+ setSteps((current) => settleProgress(current));
setRunning(true);
setRecoveryFailure(null);
// Refreshing credentials does not turn an existing installation into a first run.
@@ -497,9 +541,30 @@ export function App() {
}
}
+ async function resetLeftoverDatabase(volume: string) {
+ setBusy(true);
+ try {
+ await invoke("reset_leftover_database", {
+ root: root.trim(),
+ volume,
+ confirmed: true,
+ });
+ setFailure(null);
+ setRecoveryFailure(null);
+ setSteps([]);
+ } catch (error) {
+ setFailure(asProblem(error));
+ } finally {
+ setBusy(false);
+ }
+ }
+
function modelCanStart() {
if (!model) return false;
if (!model.saved) return true;
+ if (model.provider === "google" || model.provider === "xai") {
+ return model.login === "oauth" && Boolean(model.model?.trim());
+ }
if (model.provider === "openai-compatible") {
return (
model.login === "endpoint" &&
@@ -695,9 +760,12 @@ export function App() {
{displayedFailure && <Failure problem={displayedFailure} />}
{busy && <p role="status">Installing local software…</p>}
{installationReady && (
- <button type="button" className="quiet" onClick={install}>
- Repair installation
- </button>
+ <details>
+ <summary>Installation options</summary>
+ <button type="button" className="quiet" onClick={install}>
+ Repair installation
+ </button>
+ </details>
)}
<div className="row">
<button
@@ -849,33 +917,40 @@ export function App() {
return (
<main>
- {/* A failure outranks `running`. The supervisor gives up on a process and sends the window
+ <div className="sheet connection-sheet">
+ {/* A failure outranks `running`. The supervisor gives up on a process and sends the window
back here, and a heading that still says everything is running while the box underneath
names the process that stopped is a screen arguing with itself. */}
- {!running && !returningToInstallation && (
- <p className="steps-of">Step 4 of 4</p>
- )}
- <h1>
- {running && !displayedFailure
- ? "OpenBot is running"
- : returningToInstallation
- ? "Refresh your CopilotKit connection"
- : "Connect to CopilotKit"}
- </h1>
- <p className="lede">
- {running && !displayedFailure
- ? "The stack is up. OpenBot is in this window; the menu bar has it too, and stops it."
- : returningToInstallation
- ? "Update this connection to reopen your existing OpenBot."
- : "Local installation is complete. Connect CopilotKit, then start OpenBot."}
- </p>
+ {!running && displayedFailure?.database_reset && (
+ <DatabaseReset
+ key={`${root}:${displayedFailure.database_reset}`}
+ busy={busy}
+ volume={displayedFailure.database_reset}
+ onReset={resetLeftoverDatabase}
+ />
+ )}
- {!running && (
- <fieldset
- disabled={busy}
- style={{ border: 0, padding: 0, margin: 0, minWidth: 0 }}
- >
- {/*
+ {!running && !returningToInstallation && (
+ <p className="steps-of">Step 4 of 4</p>
+ )}
+ <h1>
+ {running && !displayedFailure
+ ? "OpenBot is running"
+ : returningToInstallation
+ ? "Refresh your CopilotKit connection"
+ : "Connect to CopilotKit"}
+ </h1>
+ <p className="lede">
+ {running && !displayedFailure
+ ? "The stack is up. OpenBot is in this window; the menu bar has it too, and stops it."
+ : returningToInstallation
+ ? "Update this connection to reopen your existing OpenBot."
+ : "Local installation is complete. Connect CopilotKit, then start OpenBot."}
+ </p>
+
+ {!running && (
+ <fieldset className="connection-form" disabled={busy}>
+ {/*
Sign in on the main path; paste behind the disclosure.
This screen used to ask for a key whose only source was two terminal commands, which is
@@ -884,10 +959,26 @@ export function App() {
Intelligence has a key this sign-in knows nothing about, so the field moves down there
with the addresses it belongs with.
*/}
- {apiKey && !signingIn && !projects ? (
- <>
- <p className="lede">Connected to CopilotKit.</p>
- {returningToInstallation && (
+ {apiKey && !signingIn && !projects ? (
+ <>
+ <p className="lede">Connected to CopilotKit.</p>
+ {returningToInstallation && (
+ <button
+ type="button"
+ className="quiet"
+ onClick={signInToCopilotKit}
+ >
+ Sign in to CopilotKit again
+ </button>
+ )}
+ </>
+ ) : (alreadyHeld.saved?.intelligenceApiKey || reuseIntelligence) &&
+ !signingIn &&
+ !projects ? (
+ <>
+ <p className="lede">
+ A saved CopilotKit connection will be checked when you start.
+ </p>
<button
type="button"
className="quiet"
@@ -895,269 +986,346 @@ export function App() {
>
Sign in to CopilotKit again
</button>
- )}
- </>
- ) : (alreadyHeld.saved?.intelligenceApiKey || reuseIntelligence) &&
- !signingIn &&
- !projects ? (
- <>
- <p className="lede">
- A saved CopilotKit connection will be checked when you start.
- </p>
- <button
- type="button"
- className="quiet"
- onClick={signInToCopilotKit}
- >
- Sign in to CopilotKit again
- </button>
- </>
- ) : signInUrl ? (
- <>
- <p className="lede">
- Finish signing in to CopilotKit in your browser. If it did not
- open, this is the address:
- </p>
- {/* Selectable text, not a link: the browser has already been asked to open it, and
+ </>
+ ) : signInUrl ? (
+ <>
+ <p className="lede">
+ Finish signing in to CopilotKit in your browser. If it did not
+ open, this is the address:
+ </p>
+ {/* Selectable text, not a link: the browser has already been asked to open it, and
what is needed here is something a person can copy. */}
- <p className="footnote" style={{ userSelect: "text" }}>
- {signInUrl}
- </p>
- <p className="footnote">Waiting for you to approve it…</p>
- </>
- ) : projects ? (
- <>
- <p className="lede">Which project should OpenBot use?</p>
- <fieldset className="picker">
- <legend className="sr-only">Project</legend>
- {projects.map((project) => (
+ <p className="footnote" style={{ userSelect: "text" }}>
+ {signInUrl}
+ </p>
+ <p className="footnote">Waiting for you to approve it…</p>
+ </>
+ ) : projects ? (
+ <>
+ <p className="lede">Which project should OpenBot use?</p>
+ <fieldset className="picker">
+ <legend className="sr-only">Project</legend>
+ {projects.map((project) => (
+ <button
+ type="button"
+ key={project.id}
+ className="tile project-choice"
+ disabled={signingIn}
+ onClick={() => pickProject(project.id)}
+ >
+ <span className="tile-name">{project.name}</span>
+ </button>
+ ))}
+ </fieldset>
+ {projects.length === 0 && (
+ <>
+ <p className="footnote">
+ That account has no projects yet. Create one below, or
+ sign in with a different account.
+ </p>
+ <button
+ type="button"
+ className="quiet"
+ disabled={signingIn}
+ onClick={signInToCopilotKit}
+ >
+ {signingIn
+ ? "Waiting for your browser…"
+ : "Sign in again"}
+ </button>
+ </>
+ )}
+ <form
+ className="new-project-form"
+ onSubmit={(event) => {
+ event.preventDefault();
+ void createProject();
+ }}
+ >
+ <div className="field">
+ <label htmlFor="new-project-name">New project name</label>
+ <input
+ id="new-project-name"
+ value={projectName}
+ onChange={(event) => setProjectName(event.target.value)}
+ disabled={signingIn}
+ autoComplete="off"
+ />
+ </div>
<button
- type="button"
- key={project.id}
- className="tile"
- disabled={signingIn}
- onClick={() => pickProject(project.id)}
+ type="submit"
+ className={projects.length > 0 ? "quiet" : undefined}
+ disabled={signingIn || !projectName.trim()}
>
- <span className="tile-name">{project.name}</span>
+ {creatingProject ? "Creating project…" : "Create project"}
</button>
- ))}
- </fieldset>
- {projects.length === 0 && (
- <>
- <p className="footnote">
- That account has no projects yet. Make one at copilotkit.ai,
- then sign in again.
- </p>
+ </form>
+ </>
+ ) : (
+ <>
+ <p className="lede">
+ OpenBot keeps your conversations in CopilotKit. Sign in and it
+ sets the rest up for you.
+ </p>
+ <div className="row connection-actions">
<button
type="button"
- className="quiet"
disabled={signingIn}
onClick={signInToCopilotKit}
>
- {signingIn ? "Waiting for your browser…" : "Sign in again"}
+ {signingIn
+ ? "Waiting for your browser…"
+ : "Sign in to CopilotKit"}
</button>
- </>
- )}
- </>
- ) : (
- <>
- <p className="lede">
- OpenBot keeps your conversations in CopilotKit. Sign in and it
- sets the rest up for you.
- </p>
- <button
- type="button"
- disabled={signingIn}
- onClick={signInToCopilotKit}
- >
- {signingIn
- ? "Waiting for your browser…"
- : "Sign in to CopilotKit"}
- </button>
- </>
- )}
- {!apiKey &&
- !reuseIntelligence &&
- alreadyHeld.saved?.intelligenceApiKey == null &&
- !signingIn &&
- !projects && (
- <button
- type="button"
- className="quiet"
- onClick={() => setReuseIntelligence(true)}
- >
- Use a saved connection
- </button>
+ {!apiKey &&
+ !reuseIntelligence &&
+ alreadyHeld.saved?.intelligenceApiKey == null &&
+ !signingIn && (
+ <button
+ type="button"
+ className="quiet"
+ onClick={() => setReuseIntelligence(true)}
+ >
+ Use a saved connection
+ </button>
+ )}
+ </div>
+ </>
)}
- {/*
+ {/*
This used to be headed "Self-hosted Intelligence" over two fields pre-filled with the
MANAGED service's addresses, which says the opposite of what it does: somebody opening
it to check where their data goes read "self-hosted" and saw CopilotKit's own hosts.
The heading now describes the action, and the note says what the defaults are.
*/}
- <details>
- <summary>Point at your own Intelligence server</summary>
- <p className="footnote" style={{ margin: "0.6rem 0 0.75rem" }}>
- These default to CopilotKit's managed service. Change them only if
- you run Intelligence yourself, and paste that server's key below.
- </p>
- <div className="field">
- <label htmlFor="key">Project key</label>
- <input
- id="key"
- type="password"
- value={apiKey}
- onChange={(event) => setApiKey(event.target.value)}
- placeholder="the key from your own Intelligence"
- autoComplete="off"
- spellCheck={false}
- />
- </div>
- <div className="field" style={{ marginTop: "0.75rem" }}>
- <label htmlFor="api">API URL</label>
- <input
- id="api"
- value={apiUrl}
- onChange={(event) => setApiUrl(event.target.value)}
- spellCheck={false}
- />
- </div>
- <div className="field">
- <label htmlFor="ws">Gateway WebSocket URL</label>
- <input
- id="ws"
- value={wsUrl}
- onChange={(event) => setWsUrl(event.target.value)}
- spellCheck={false}
- />
- </div>
- </details>
- <details>
- <summary>Sign in through your organization</summary>
- <p className="footnote">
- Enter your organization’s OpenBot address to use its sign-in and
- access rules.
- </p>
- <div className="field">
- <label htmlFor="organization-authority">
- Organization OpenBot URL
- </label>
- <input
- id="organization-authority"
- value={organizationAuthorityUrl ?? ""}
- onChange={(event) =>
- setOrganizationAuthorityUrl(event.target.value)
- }
- placeholder="https://openbot.your-company.com"
- spellCheck={false}
- />
- </div>
- </details>
- </fieldset>
- )}
+ <details>
+ <summary>Point at your own Intelligence server</summary>
+ <p className="footnote" style={{ margin: "0.6rem 0 0.75rem" }}>
+ These default to CopilotKit's managed service. Change them only
+ if you run Intelligence yourself, and paste that server's key
+ below.
+ </p>
+ <div className="field">
+ <label htmlFor="key">Project key</label>
+ <input
+ id="key"
+ type="password"
+ value={apiKey}
+ onChange={(event) => setApiKey(event.target.value)}
+ placeholder="the key from your own Intelligence"
+ autoComplete="off"
+ spellCheck={false}
+ />
+ </div>
+ <div className="field" style={{ marginTop: "0.75rem" }}>
+ <label htmlFor="api">API URL</label>
+ <input
+ id="api"
+ value={apiUrl}
+ onChange={(event) => setApiUrl(event.target.value)}
+ spellCheck={false}
+ />
+ </div>
+ <div className="field">
+ <label htmlFor="ws">Gateway WebSocket URL</label>
+ <input
+ id="ws"
+ value={wsUrl}
+ onChange={(event) => setWsUrl(event.target.value)}
+ spellCheck={false}
+ />
+ </div>
+ </details>
+ <details>
+ <summary>Sign in through your organization</summary>
+ <p className="footnote">
+ Enter your organization’s OpenBot address to use its sign-in and
+ access rules.
+ </p>
+ <div className="field">
+ <label htmlFor="organization-authority">
+ Organization OpenBot URL
+ </label>
+ <input
+ id="organization-authority"
+ value={organizationAuthorityUrl ?? ""}
+ onChange={(event) =>
+ setOrganizationAuthorityUrl(event.target.value)
+ }
+ placeholder="https://openbot.your-company.com"
+ spellCheck={false}
+ />
+ </div>
+ </details>
+ </fieldset>
+ )}
- <SetupProgress steps={steps} />
+ <SetupProgress steps={steps} />
- {displayedFailure && <Failure problem={displayedFailure} />}
+ {displayedFailure && <Failure problem={displayedFailure} />}
- {!running && !returningToInstallation && (
- <button
- type="button"
- className="quiet"
- disabled={busy || signingIn}
- onClick={() => {
- setPreparation(null);
- setSteps([]);
- setStep("install");
- }}
- >
- Change installation
- </button>
- )}
- {!running && (
- <button
- type="button"
- className="quiet"
- disabled={busy || signingIn}
- onClick={() =>
- returningToInstallation
- ? setRefreshIntelligence(false)
- : setStep("model")
- }
- >
- {returningToInstallation ? "Back" : "Change AI connection"}
- </button>
- )}
- <div className="row">
- {running ? (
- <>
+ {!running && !returningToInstallation && (
+ <details>
+ <summary>Installation options</summary>
+ <button
+ type="button"
+ className="quiet"
+ disabled={busy || signingIn}
+ onClick={() => {
+ setPreparation(null);
+ setSteps([]);
+ setStep("install");
+ }}
+ >
+ Change installation
+ </button>
+ </details>
+ )}
+ <div className="row">
+ {!running && (
<button
type="button"
- /*
- * The refusal is shown, not swallowed.
- *
- * `show_openbot` answers with "OpenBot is not answering on port 3010 yet, so there
- * is nothing to show" when the app host process is not up, and this button dropped
- * it on the floor. Clicking it then did nothing at all, on a screen headed "OpenBot
- * is running", which is the worst of both: a true sentence was available and the
- * window threw it away. The Ask screen's copy of this call always showed it.
- */
+ className="quiet"
+ disabled={busy || signingIn}
onClick={() =>
- invoke("show_openbot").catch((error) => recoverFromStart(error))
+ returningToInstallation
+ ? setRefreshIntelligence(false)
+ : setStep("model")
}
>
- Show OpenBot
+ Back
</button>
+ )}
+ {running ? (
+ <>
+ <button
+ type="button"
+ /*
+ * The refusal is shown, not swallowed.
+ *
+ * `show_openbot` answers with "OpenBot is not answering on port 3010 yet, so there
+ * is nothing to show" when the app host process is not up, and this button dropped
+ * it on the floor. Clicking it then did nothing at all, on a screen headed "OpenBot
+ * is running", which is the worst of both: a true sentence was available and the
+ * window threw it away. The Ask screen's copy of this call always showed it.
+ */
+ onClick={() =>
+ invoke("show_openbot").catch((error) =>
+ recoverFromStart(error),
+ )
+ }
+ >
+ Show OpenBot
+ </button>
+ <button
+ type="button"
+ className="quiet"
+ onClick={stop}
+ disabled={busy}
+ >
+ Stop OpenBot
+ </button>
+ </>
+ ) : (
<button
type="button"
- className="quiet"
- onClick={stop}
- disabled={busy}
+ onClick={() => start()}
+ // The model is answered by its own screen now, so what is checked here is that it was
+ // answered at all, not that some field on this screen is non-empty.
+ disabled={
+ busy ||
+ signingIn ||
+ !installationReady ||
+ (apiKey.trim() === "" &&
+ !alreadyHeld.saved?.intelligenceApiKey &&
+ !reuseIntelligence) ||
+ !modelCanStart() ||
+ root.trim() === ""
+ }
>
- Stop OpenBot
+ {busy ? "Working…" : "Start OpenBot"}
</button>
- </>
- ) : (
- <button
- type="button"
- onClick={() => start()}
- // The model is answered by its own screen now, so what is checked here is that it was
- // answered at all, not that some field on this screen is non-empty.
- disabled={
- busy ||
- !installationReady ||
- (apiKey.trim() === "" &&
- !alreadyHeld.saved?.intelligenceApiKey &&
- !reuseIntelligence) ||
- !modelCanStart() ||
- root.trim() === ""
- }
- >
- {busy ? "Working…" : "Start OpenBot"}
- </button>
- )}
+ )}
+ </div>
</div>
</main>
);
}
+function settleProgress(steps: Progress[], problem?: Problem): Progress[] {
+ return steps.map((step) =>
+ step.running
+ ? {
+ ...step,
+ running: false,
+ ok: !problem,
+ detail: problem?.said ?? "Finished.",
+ }
+ : step,
+ );
+}
+
function SetupProgress({ steps }: { steps: Progress[] }) {
if (steps.length === 0) return null;
return (
- <div className="steps" aria-live="polite">
+ <ol className="steps" aria-label="Setup progress" aria-live="polite">
{steps.map((step) => (
- <div className="step" key={step.step}>
- <span className={`mark ${step.ok ? "good" : "bad"}`}>
- {step.ok ? "✓" : "✗"}
- </span>
- <span>{label(step.step)}</span>
- <span className="detail">{step.detail}</span>
- </div>
+ <SetupProgressRow key={step.step} step={step} />
))}
- </div>
+ </ol>
);
}
+function SetupProgressRow({ step }: { step: Progress }) {
+ const [elapsed, setElapsed] = useState(0);
+ const running = step.running ?? false;
+ useEffect(() => {
+ if (!running) return;
+ const started = Date.now();
+ setElapsed(0);
+ const timer = setInterval(
+ () => setElapsed(Math.floor((Date.now() - started) / 1000)),
+ 1000,
+ );
+ return () => clearInterval(timer);
+ }, [running]);
+ return (
+ <li className="step" aria-label={label(step.step)}>
+ <span
+ className={`mark ${running ? "active" : step.ok ? "good" : "bad"}`}
+ aria-hidden="true"
+ >
+ {running ? <span className="step-spinner" /> : step.ok ? "✓" : "✗"}
+ </span>
+ <span className="step-label">{label(step.step)}</span>
+ <span className="step-status">
+ {running ? "In progress" : step.ok ? "Complete" : "Failed"}
+ {running && (
+ <span className="step-elapsed" aria-hidden="true" aria-live="off">
+ {" · "}
+ {elapsed < 60
+ ? `${elapsed}s`
+ : `${Math.floor(elapsed / 60)}m ${elapsed % 60}s`}{" "}
+ elapsed
+ </span>
+ )}
+ </span>
+ <span className="detail">
+ {step.detail}
+ {step.downloadBytes != null &&
+ ` ${formatDownloadBytes(step.downloadBytes)} downloaded.`}
+ </span>
+ </li>
+ );
+}
+
+function formatDownloadBytes(bytes: number): string {
+ if (bytes < 1000) return `${bytes} B`;
+ const units = ["kB", "MB", "GB", "TB"];
+ const power = Math.min(Math.floor(Math.log10(bytes) / 3), units.length);
+ return `${(bytes / 1000 ** power).toFixed(1)} ${units[power - 1]}`;
+}
+
function titleFor(blocker: Blocker): string {
switch (blocker) {
case "wsl-absent":
@@ -1175,6 +1343,7 @@ function titleFor(blocker: Blocker): string {
function label(step: string): string {
switch (step) {
+ case "engine":
case "install-engine":
return "Container engine";
case "create-machine":
diff --git a/desktop/src/DatabaseReset.tsx b/desktop/src/DatabaseReset.tsx
new file mode 100644
index 00000000..8d3dcd46
--- /dev/null
+++ b/desktop/src/DatabaseReset.tsx
@@ -0,0 +1,52 @@
+import { useState } from "react";
+
+/** Only rendered when native setup has identified a recoverable leftover database. */
+export function DatabaseReset({
+ busy,
+ onReset,
+ volume,
+}: {
+ busy: boolean;
+ volume: string;
+ onReset: (volume: string) => Promise<void>;
+}) {
+ const [confirming, setConfirming] = useState(false);
+ if (!confirming) {
+ return (
+ <button
+ type="button"
+ className="quiet"
+ disabled={busy}
+ onClick={() => setConfirming(true)}
+ >
+ Reset leftover database
+ </button>
+ );
+ }
+ return (
+ <section className="blocker" aria-labelledby="database-reset-title">
+ <h2 id="database-reset-title">
+ Delete the previous installation’s data?
+ </h2>
+ <p>
+ This permanently deletes the local OpenBot database, including saved
+ chats, Bots, and settings. Only continue if you want a fresh
+ installation and do not need that data.
+ </p>
+ <p>To keep your data, restore its original encryption key instead.</p>
+ <div className="row">
+ <button
+ type="button"
+ className="quiet"
+ disabled={busy}
+ onClick={() => setConfirming(false)}
+ >
+ Keep saved data
+ </button>
+ <button type="button" disabled={busy} onClick={() => onReset(volume)}>
+ {busy ? "Deleting saved data…" : "Delete saved data"}
+ </button>
+ </div>
+ </section>
+ );
+}
diff --git a/desktop/src/ExternalLink.tsx b/desktop/src/ExternalLink.tsx
new file mode 100644
index 00000000..c1be4507
--- /dev/null
+++ b/desktop/src/ExternalLink.tsx
@@ -0,0 +1,46 @@
+import { invoke } from "@tauri-apps/api/core";
+import { type MouseEvent, type ReactNode, useState } from "react";
+
+/** Open setup links explicitly so a refused browser launch is visible and retryable. */
+export function ExternalLink({
+ href,
+ className,
+ children,
+}: {
+ href: string;
+ className?: string;
+ children: ReactNode;
+}) {
+ const [failure, setFailure] = useState<string | null>(null);
+
+ async function open(event: MouseEvent<HTMLAnchorElement>) {
+ event.preventDefault();
+ setFailure(null);
+ try {
+ // This is the opener plugin's openUrl command; keep the URL separate from any form data.
+ await invoke("plugin:opener|open_url", { url: href });
+ } catch (error) {
+ setFailure(String(error));
+ }
+ }
+
+ return (
+ <>
+ <a
+ className={className}
+ href={href}
+ target="_blank"
+ rel="noreferrer"
+ onClick={open}
+ >
+ {children}
+ </a>
+ {failure && (
+ <span className="external-link-error" role="alert">
+ Could not open your browser. Try the link again or open {href}{" "}
+ manually. ({failure})
+ </span>
+ )}
+ </>
+ );
+}
diff --git a/desktop/src/Problem.test.tsx b/desktop/src/Problem.test.tsx
index f07c7acd..03f925ea 100644
--- a/desktop/src/Problem.test.tsx
+++ b/desktop/src/Problem.test.tsx
@@ -1,21 +1,33 @@
import { afterAll, afterEach, beforeAll, expect, mock, test } from "bun:test";
import { GlobalRegistrator } from "@happy-dom/global-registrator";
-import { cleanup, render } from "@testing-library/react";
+import { cleanup, fireEvent, render, waitFor } from "@testing-library/react";
let invokeCalls: Array<{ command: string; args?: unknown }> = [];
+let invokeFailure: string | null = null;
mock.module("@tauri-apps/api/core", () => ({
invoke: (command: string, args?: unknown) => {
invokeCalls.push({ command, args });
+ if (invokeFailure) return Promise.reject(invokeFailure);
return Promise.resolve(null);
},
}));
-const { Failure } = await import("./Problem");
+const { Failure, InlineFailure } = await import("./Problem");
-beforeAll(() => GlobalRegistrator.register());
+const previousSupportUrl = process.env.VITE_OPENBOT_SUPPORT_URL;
+
+beforeAll(() =>
+ GlobalRegistrator.register({
+ settings: { navigation: { disableChildPageNavigation: true } },
+ }),
+);
afterEach(() => {
invokeCalls = [];
+ invokeFailure = null;
+ if (previousSupportUrl === undefined)
+ delete process.env.VITE_OPENBOT_SUPPORT_URL;
+ else process.env.VITE_OPENBOT_SUPPORT_URL = previousSupportUrl;
cleanup();
});
afterAll(() => GlobalRegistrator.unregister());
@@ -36,3 +48,69 @@ test("problem_ui_has_no_credential_restore_action", () => {
expect(view.queryByRole("button")).toBeNull();
expect(invokeCalls).toEqual([]);
});
+
+for (const Component of [Failure, InlineFailure]) {
+ test(`${Component.name} offers external setup help without including error data`, () => {
+ delete process.env.VITE_OPENBOT_SUPPORT_URL;
+ const view = render(
+ <Component
+ problem={{
+ said: "Synthetic start failure for [email protected].",
+ detail: "API_KEY=synthetic-private-key /Users/private-user/install",
+ }}
+ />,
+ );
+ const help = view.getByRole("link", { name: "Get setup help" });
+ expect(help.getAttribute("href")).toBe(
+ "https://github.com/CopilotKit/OpenBot/issues/new/choose",
+ );
+ expect(help.getAttribute("target")).toBe("_blank");
+ expect(help.getAttribute("rel")).toBe("noreferrer");
+ expect(invokeCalls).toEqual([]);
+ fireEvent.click(help);
+ expect(invokeCalls).toEqual([
+ {
+ command: "plugin:opener|open_url",
+ args: {
+ url: "https://github.com/CopilotKit/OpenBot/issues/new/choose",
+ },
+ },
+ ]);
+ });
+}
+
+test("setup help honors a branded support URL", () => {
+ process.env.VITE_OPENBOT_SUPPORT_URL = "https://support.example.test/openbot";
+ const view = render(<Failure problem={{ said: "Synthetic failure." }} />);
+ expect(
+ view.getByRole("link", { name: "Get setup help" }).getAttribute("href"),
+ ).toBe("https://support.example.test/openbot");
+ fireEvent.click(view.getByRole("link", { name: "Get setup help" }));
+ expect(invokeCalls).toEqual([
+ {
+ command: "plugin:opener|open_url",
+ args: { url: "https://support.example.test/openbot" },
+ },
+ ]);
+});
+
+test("setup help reports a failed browser open and allows retry", async () => {
+ delete process.env.VITE_OPENBOT_SUPPORT_URL;
+ invokeFailure = "synthetic browser refusal";
+ const view = render(<Failure problem={{ said: "Synthetic failure." }} />);
+ const help = view.getByRole("link", { name: "Get setup help" });
+
+ fireEvent.click(help);
+ const failure = await view.findByText(/Could not open your browser/);
+ expect(failure.textContent).toContain("synthetic browser refusal");
+ expect(failure.textContent).toContain(
+ "https://github.com/CopilotKit/OpenBot/issues/new/choose",
+ );
+
+ invokeFailure = null;
+ fireEvent.click(help);
+ await waitFor(() =>
+ expect(view.queryByText(/Could not open your browser/) === null).toBe(true),
+ );
+ expect(invokeCalls).toHaveLength(2);
+});
diff --git a/desktop/src/Problem.tsx b/desktop/src/Problem.tsx
index 4d78bae0..723f93ed 100644
--- a/desktop/src/Problem.tsx
+++ b/desktop/src/Problem.tsx
@@ -1,3 +1,5 @@
+import { ExternalLink } from "./ExternalLink";
+
/**
* A failure, in both registers, wherever one happens.
*
@@ -10,6 +12,7 @@ export type Problem = {
said: string;
detail?: string | null;
connection?: "model" | "intelligence" | "organization" | null;
+ database_reset?: string | null;
};
/** Anything thrown, as a problem. A bare string keeps working and reads as it always did. */
@@ -20,6 +23,18 @@ export function asProblem(thrown: unknown): Problem {
return { said: String(thrown) };
}
+function SetupHelp() {
+ // Whitelabel builds can choose their own support page. Never prefill it with error data.
+ const url =
+ import.meta.env.VITE_OPENBOT_SUPPORT_URL?.trim() ||
+ "https://github.com/CopilotKit/OpenBot/issues/new/choose";
+ return (
+ <ExternalLink className="setup-help" href={url}>
+ Get setup help
+ </ExternalLink>
+ );
+}
+
export function Failure({ problem }: { problem: Problem }) {
return (
<div className="blocker" role="alert">
@@ -33,6 +48,7 @@ export function Failure({ problem }: { problem: Problem }) {
<pre>{problem.detail}</pre>
</details>
)}
+ <SetupHelp />
</div>
);
}
@@ -54,6 +70,7 @@ export function InlineFailure({ problem }: { problem: Problem }) {
<pre>{problem.detail}</pre>
</details>
)}
+ <SetupHelp />
</div>
);
}
diff --git a/desktop/src/ProviderPicker.test.tsx b/desktop/src/ProviderPicker.test.tsx
index 94381c84..a976856d 100644
--- a/desktop/src/ProviderPicker.test.tsx
+++ b/desktop/src/ProviderPicker.test.tsx
@@ -2,7 +2,11 @@ import { afterAll, afterEach, beforeAll, expect, mock, test } from "bun:test";
import { GlobalRegistrator } from "@happy-dom/global-registrator";
import { act, cleanup, render, waitFor } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
-import type { HeldConfiguration, Provider } from "./ProviderPicker";
+import type {
+ HeldConfiguration,
+ ModelChoice,
+ Provider,
+} from "./ProviderPicker";
const providers: Provider[] = [
{
@@ -34,6 +38,38 @@ const endpointProviders: Provider[] = [
},
];
+const cloudProviders = [
+ {
+ id: "google",
+ name: "Google Gemini",
+ baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai/",
+ model: "gemini-3.8-flash",
+ keyUrl: "https://aistudio.google.com/apikey",
+ },
+ {
+ id: "xai",
+ name: "xAI",
+ baseUrl: "https://api.x.ai/v1",
+ model: "grok-4.7",
+ keyUrl: "https://console.x.ai/",
+ },
+];
+
+const allProviders: Provider[] = [
+ ...providers,
+ ...cloudProviders.map(
+ (provider): Provider => ({
+ id: provider.id,
+ name: provider.name,
+ summary: "Use an API key.",
+ logins: ["endpoint"],
+ mark: null,
+ caution: null,
+ }),
+ ),
+ ...endpointProviders,
+];
+
type Invoke = (command: string, args?: unknown) => Promise<unknown>;
let invokeCalls: Array<{ command: string; args?: unknown }> = [];
@@ -58,7 +94,11 @@ mock.module("./Mark", () => ({
const { ProviderPicker } = await import("./ProviderPicker");
-beforeAll(() => GlobalRegistrator.register());
+beforeAll(() =>
+ GlobalRegistrator.register({
+ settings: { navigation: { disableChildPageNavigation: true } },
+ }),
+);
afterEach(() => {
invokeCalls = [];
cleanup();
@@ -767,3 +807,283 @@ test("a saved keyless endpoint never requests a saved first-party key", async ()
},
]);
});
+
+test("OAuth tab switch cancels a late authorization before opening the browser", async () => {
+ let resolveBegin!: (value: unknown) => void;
+ invokeHandler = async (command) => {
+ if (command === "providers")
+ return allProviders.map((row) =>
+ row.id === "xai" ? { ...row, logins: ["endpoint", "oauth"] } : row,
+ );
+ if (command === "begin_model_oauth")
+ return new Promise((resolve) => {
+ resolveBegin = resolve;
+ });
+ if (command === "cancel_model_oauth") return null;
+ throw new Error(`unexpected command ${command}`);
+ };
+ const view = await renderPicker();
+ const user = userEvent.setup({ document: view.container.ownerDocument });
+ await user.click(await view.findByRole("radio", { name: /xAI/ }));
+ await user.click(view.getByRole("tab", { name: "Sign in" }));
+ await user.click(view.getByRole("button", { name: "Sign in with xAI" }));
+ await user.click(view.getByRole("tab", { name: "Use an API key" }));
+ await act(async () => {
+ resolveBegin({
+ attemptId: "late-attempt",
+ url: "https://authorization.example.test",
+ userCode: null,
+ });
+ });
+ expect(invokeCalls).toContainEqual({
+ command: "cancel_model_oauth",
+ args: { attemptId: "late-attempt" },
+ });
+ expect(
+ invokeCalls.some((call) => call.command === "plugin:opener|open_url"),
+ ).toBe(false);
+ expect(view.getByRole("button", { name: "Continue" })).toHaveProperty(
+ "disabled",
+ true,
+ );
+});
+
+for (const provider of cloudProviders) {
+ test(`${provider.name} OAuth completes through native storage without exposing tokens`, async () => {
+ invokeHandler = async (command) => {
+ if (command === "providers")
+ return allProviders.map((row) =>
+ row.id === provider.id
+ ? { ...row, logins: ["endpoint", "oauth"] }
+ : row,
+ );
+ if (command === "begin_model_oauth")
+ return {
+ attemptId: "synthetic-attempt",
+ url: "https://authorization.example.test/approve",
+ userCode: "SYNTHETIC",
+ };
+ if (
+ command === "plugin:opener|open_url" ||
+ command === "finish_model_oauth"
+ )
+ return null;
+ throw new Error(`unexpected command ${command}`);
+ };
+ const choices: unknown[] = [];
+ const view = await renderPicker((choice) => choices.push(choice));
+ const user = userEvent.setup({ document: view.container.ownerDocument });
+ await user.click(
+ await view.findByRole("radio", { name: new RegExp(provider.name) }),
+ );
+ await user.click(view.getByRole("tab", { name: "Sign in" }));
+ await user.click(
+ view.getByRole("button", { name: `Sign in with ${provider.name}` }),
+ );
+ await view.findByText(`Signed in to ${provider.name}.`);
+ await user.click(view.getByRole("button", { name: "Continue" }));
+ expect(choices).toEqual([
+ {
+ provider: provider.id,
+ login: "oauth",
+ model: provider.model,
+ saved: true,
+ },
+ ]);
+ expect(invokeCalls).toContainEqual({
+ command: "begin_model_oauth",
+ args: { root: "/tmp/openbot-provider-root", provider: provider.id },
+ });
+ expect(invokeCalls).toContainEqual({
+ command: "finish_model_oauth",
+ args: { attemptId: "synthetic-attempt" },
+ });
+ });
+
+ test(`${provider.name} opens its API key page externally without sending entered credentials`, async () => {
+ invokeHandler = async (command) => {
+ if (command === "providers") return allProviders;
+ if (command === "plugin:opener|open_url") return null;
+ throw new Error(`unexpected command ${command}`);
+ };
+ const view = await renderPicker();
+ const user = userEvent.setup({ document: view.container.ownerDocument });
+ await user.click(
+ await view.findByRole("radio", { name: new RegExp(provider.name) }),
+ );
+ await user.type(
+ view.getByLabelText(`${provider.name} API key`),
+ "synthetic-private-api-key",
+ );
+ expect(invokeCalls.map((call) => call.command)).toEqual(["providers"]);
+ await user.click(
+ view.getByRole("link", { name: `Get a ${provider.name} API key` }),
+ );
+ expect(invokeCalls).toEqual([
+ { command: "providers", args: undefined },
+ { command: "plugin:opener|open_url", args: { url: provider.keyUrl } },
+ ]);
+ });
+
+ test(`${provider.name} uses its official endpoint and editable model with an API key`, async () => {
+ invokeHandler = async (command) => {
+ if (command === "providers") return allProviders;
+ throw new Error(`unexpected protected command ${command}`);
+ };
+ const user = userEvent.setup({ document });
+ const choices: unknown[] = [];
+ const view = await renderPicker((choice) => choices.push(choice));
+ await user.click(
+ await view.findByRole("radio", { name: new RegExp(provider.name) }),
+ );
+
+ expect(view.getByLabelText("Model name")).toHaveProperty(
+ "value",
+ provider.model,
+ );
+ expect(view.queryByLabelText("Base URL")).toBeNull();
+ expect(
+ view.queryByRole("tab", { name: "Sign in with my plan" }),
+ ).toBeNull();
+ expect(view.getByRole("button", { name: "Continue" })).toHaveProperty(
+ "disabled",
+ true,
+ );
+ await user.type(
+ view.getByLabelText(`${provider.name} API key`),
+ "synthetic-provider-key",
+ );
+ await user.click(view.getByRole("button", { name: "Continue" }));
+ expect(choices[0]).toEqual({
+ provider: "openai-compatible",
+ login: "endpoint",
+ baseUrl: provider.baseUrl,
+ model: provider.model,
+ apiKey: "synthetic-provider-key",
+ });
+ await user.clear(view.getByLabelText("Model name"));
+ await user.type(
+ view.getByLabelText("Model name"),
+ "another-compatible-model",
+ );
+ await user.click(view.getByRole("button", { name: "Continue" }));
+ expect(choices[1]).toEqual({
+ provider: "openai-compatible",
+ login: "endpoint",
+ baseUrl: provider.baseUrl,
+ model: "another-compatible-model",
+ apiKey: "synthetic-provider-key",
+ });
+ });
+
+ test(`${provider.name} restores its choice when returning from the next setup step`, async () => {
+ invokeHandler = async (command) => {
+ if (command === "providers") return allProviders;
+ throw new Error(`unexpected protected command ${command}`);
+ };
+ const chosen: ModelChoice = {
+ provider: "openai-compatible",
+ login: "endpoint",
+ baseUrl: provider.baseUrl,
+ model: "chosen-model",
+ apiKey: "synthetic-returning-key",
+ };
+ const choices: ModelChoice[] = [];
+ let view!: ReturnType<typeof render>;
+ await act(async () => {
+ view = render(
+ <ProviderPicker
+ chosen={chosen}
+ held={{}}
+ root="/tmp/provider-return"
+ onBack={() => {}}
+ onChoose={(choice) => choices.push(choice)}
+ />,
+ );
+ });
+ expect(
+ await view.findByRole("radio", { name: new RegExp(provider.name) }),
+ ).toHaveProperty("checked", true);
+ expect(view.getByLabelText(`${provider.name} API key`)).toHaveProperty(
+ "value",
+ "synthetic-returning-key",
+ );
+ expect(view.getByLabelText("Model name")).toHaveProperty(
+ "value",
+ "chosen-model",
+ );
+ await userEvent.click(view.getByRole("button", { name: "Continue" }));
+ expect(choices).toEqual([chosen]);
+ });
+
+ test(`${provider.name} recognizes a saved endpoint but never carries its key to another provider`, async () => {
+ invokeHandler = async (command) => {
+ if (command === "providers") return allProviders;
+ throw new Error(`unexpected protected command ${command}`);
+ };
+ // A trailing slash is an equivalent UI identity, but the saved URL itself must
+ // survive unchanged so backend credential matching remains endpoint-scoped.
+ const savedUrl = provider.baseUrl.endsWith("/")
+ ? provider.baseUrl.slice(0, -1)
+ : `${provider.baseUrl}/`;
+ const choices: unknown[] = [];
+ const view = await renderPickerWithHeld(
+ {
+ OPENAI_BASE_URL: savedUrl,
+ BOT_MODEL: "saved-model",
+ saved: {
+ model: "compatible-endpoint",
+ modelApiKeys: { compatible: true, openai: true },
+ },
+ },
+ (choice) => choices.push(choice),
+ );
+ expect(
+ await view.findByRole("radio", { name: new RegExp(provider.name) }),
+ ).toHaveProperty("checked", true);
+ expect(view.getByLabelText(`${provider.name} API key`)).toHaveProperty(
+ "value",
+ "",
+ );
+ await userEvent.click(view.getByRole("button", { name: "Continue" }));
+ expect(choices[0]).toEqual({
+ provider: "openai-compatible",
+ login: "endpoint",
+ baseUrl: savedUrl,
+ model: "saved-model",
+ saved: true,
+ });
+
+ await userEvent.type(
+ view.getByLabelText(`${provider.name} API key`),
+ "synthetic-replacement-key",
+ );
+ const other = cloudProviders.find(
+ (candidate) => candidate.id !== provider.id,
+ )!;
+ await userEvent.click(
+ view.getByRole("radio", { name: new RegExp(other.name) }),
+ );
+ expect(view.getByLabelText(`${other.name} API key`)).toHaveProperty(
+ "value",
+ "",
+ );
+ expect(view.queryByText(/A saved API key for this endpoint/)).toBeNull();
+ expect(view.getByRole("button", { name: "Continue" })).toHaveProperty(
+ "disabled",
+ true,
+ );
+ await userEvent.type(
+ view.getByLabelText(`${other.name} API key`),
+ "synthetic-other-key",
+ );
+ await userEvent.click(view.getByRole("button", { name: "Continue" }));
+ expect(choices[1]).toEqual({
+ provider: "openai-compatible",
+ login: "endpoint",
+ baseUrl: other.baseUrl,
+ model: other.model,
+ apiKey: "synthetic-other-key",
+ });
+ });
+}
diff --git a/desktop/src/ProviderPicker.tsx b/desktop/src/ProviderPicker.tsx
index 8acfd578..c4cd3eb9 100644
--- a/desktop/src/ProviderPicker.tsx
+++ b/desktop/src/ProviderPicker.tsx
@@ -1,11 +1,12 @@
import { invoke } from "@tauri-apps/api/core";
import { listen } from "@tauri-apps/api/event";
import { useEffect, useRef, useState } from "react";
+import { ExternalLink } from "./ExternalLink";
import { isHttpEndpointUrl } from "./http-endpoint-url";
import { Mark } from "./Mark";
import { asProblem, InlineFailure, type Problem } from "./Problem";
-export type Login = "plan" | "api-key" | "endpoint";
+export type Login = "plan" | "api-key" | "endpoint" | "oauth";
export type Provider = {
id: string;
@@ -37,12 +38,16 @@ export type SavedConfiguration = {
| "claude-plan"
| "chat-gpt-plan"
| "compatible-endpoint"
+ | "google-oauth"
+ | "xai-oauth"
| null;
intelligenceApiKey?: boolean | null;
modelApiKeys?: Partial<
Record<"openai" | "anthropic" | "compatible", boolean | null>
>;
- modelSessions?: Partial<Record<"openai" | "anthropic", boolean | null>>;
+ modelSessions?: Partial<
+ Record<"openai" | "anthropic" | "google" | "xai", boolean | null>
+ >;
};
export type HeldConfiguration = {
@@ -57,6 +62,42 @@ export type HeldConfiguration = {
saved?: SavedConfiguration;
};
+const endpointPresets: Record<
+ string,
+ { baseUrl: string; model: string; keyUrl: string }
+> = {
+ // https://ai.google.dev/gemini-api/docs/openai
+ google: {
+ baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai/",
+ model: "gemini-3.8-flash",
+ keyUrl: "https://aistudio.google.com/apikey",
+ },
+ // https://docs.x.ai/developers/model-capabilities/legacy/chat-completions
+ xai: {
+ baseUrl: "https://api.x.ai/v1",
+ model: "grok-4.7",
+ keyUrl: "https://console.x.ai/",
+ },
+};
+
+function endpointIdentity(baseUrl: string | undefined): string {
+ if (!baseUrl) return "";
+ try {
+ return new URL(baseUrl.trim()).href.replace(/\/+$/, "");
+ } catch {
+ return "";
+ }
+}
+
+function endpointProvider(baseUrl: string | undefined): string {
+ return (
+ Object.entries(endpointPresets).find(
+ ([, preset]) =>
+ endpointIdentity(preset.baseUrl) === endpointIdentity(baseUrl),
+ )?.[0] ?? "openai-compatible"
+ );
+}
+
export function recordedModel(held: HeldConfiguration): ModelChoice | null {
switch (held.saved?.model) {
case "open-ai-api-key":
@@ -67,6 +108,14 @@ export function recordedModel(held: HeldConfiguration): ModelChoice | null {
return { provider: "anthropic", login: "plan", saved: true };
case "chat-gpt-plan":
return { provider: "openai", login: "plan", saved: true };
+ case "google-oauth":
+ case "xai-oauth":
+ return {
+ provider: held.saved.model === "google-oauth" ? "google" : "xai",
+ login: "oauth",
+ saved: true,
+ model: held.BOT_MODEL,
+ };
case "compatible-endpoint":
return {
provider: "openai-compatible",
@@ -84,13 +133,8 @@ export function recordedModel(held: HeldConfiguration): ModelChoice | null {
/**
* Connect a model.
*
- * Two providers are first-class and everything else is one row, which is the shape rather than a
- * shortlist. See the build doc: growing this into a directory is how the screen stops being
- * finishable by somebody who has never opened a terminal.
- *
- * A PLAN IS THE DEFAULT WHEREVER ONE EXISTS, and the key sits beside it rather than behind it.
- * Anybody with a key and a base URL to hand is a developer; everybody else has a plan they already
- * pay for, and asking them for a key is asking them to go and get one.
+ * Plans remain the default wherever supported. Google and xAI use the same endpoint credential
+ * route as custom models, while their named rows supply the address for the user.
*/
export function ProviderPicker({
chosen,
@@ -123,7 +167,9 @@ export function ProviderPicker({
);
const [rows, setRows] = useState<Provider[]>([]);
const [open, setOpen] = useState<string | null>(
- initialChoice?.provider ?? null,
+ initialChoice?.provider === "openai-compatible"
+ ? endpointProvider(initialChoice.baseUrl)
+ : (initialChoice?.provider ?? null),
);
const [login, setLogin] = useState<Login | null>(
initialChoice?.login ?? null,
@@ -166,6 +212,96 @@ export function ProviderPicker({
const [failure, setFailure] = useState<Problem | null>(null);
const openRef = useRef(open);
const signInRunRef = useRef(0);
+ const oauthAttempt = useRef<string | null>(null);
+ const [oauthCode, setOauthCode] = useState<string | null>(null);
+ const [oauthSignedIn, setOauthSignedIn] = useState<string | null>(
+ initialChoice?.login === "oauth" && initialChoice.saved
+ ? initialChoice.provider
+ : null,
+ );
+
+ async function cancelOAuth() {
+ signInRunRef.current += 1;
+ const attemptId = oauthAttempt.current;
+ oauthAttempt.current = null;
+ setBusy(false);
+ setSignInUrl(null);
+ setOauthCode(null);
+ if (attemptId) {
+ try {
+ await invoke("cancel_model_oauth", { attemptId });
+ } catch (error) {
+ setFailure(asProblem(error));
+ }
+ }
+ }
+
+ async function beginOAuth() {
+ if (!row) return;
+ const providerId = row.id;
+ const run = ++signInRunRef.current;
+ const current = () =>
+ signInRunRef.current === run && openRef.current === providerId;
+ setBusy(true);
+ setFailure(null);
+ setOauthSignedIn(null);
+ try {
+ const authorization = await invoke<{
+ attemptId: string;
+ url: string;
+ userCode: string | null;
+ }>("begin_model_oauth", { root: root.trim(), provider: providerId });
+ if (!current()) {
+ await invoke("cancel_model_oauth", {
+ attemptId: authorization.attemptId,
+ });
+ return;
+ }
+ oauthAttempt.current = authorization.attemptId;
+ setSignInUrl(authorization.url);
+ setOauthCode(authorization.userCode);
+ try {
+ await invoke("plugin:opener|open_url", { url: authorization.url });
+ } catch (error) {
+ if (current()) setFailure(asProblem(error));
+ }
+ await invoke("finish_model_oauth", {
+ attemptId: authorization.attemptId,
+ });
+ if (current()) {
+ setOauthSignedIn(providerId);
+ setSignInUrl(null);
+ setOauthCode(null);
+ setFailure(null);
+ }
+ } catch (error) {
+ if (current()) {
+ setFailure(asProblem(error));
+ setSignInUrl(null);
+ setOauthCode(null);
+ }
+ } finally {
+ if (current()) {
+ oauthAttempt.current = null;
+ setBusy(false);
+ }
+ }
+ }
+
+ useEffect(
+ () => () => {
+ signInRunRef.current += 1;
+ const attemptId = oauthAttempt.current;
+ if (attemptId) {
+ invoke("cancel_model_oauth", { attemptId }).catch(() => {
+ console.error(
+ "OpenBot could not cancel the pending provider sign-in.",
+ );
+ });
+ }
+ },
+ [],
+ );
useEffect(() => {
openRef.current = open;
@@ -265,6 +401,7 @@ export function ProviderPicker({
}, []);
const row = rows.find((r) => r.id === open) ?? null;
+ const preset = row ? endpointPresets[row.id] : undefined;
const token = row ? (tokens[row.id] ?? "") : "";
const savedPlan =
row?.id === "openai" || row?.id === "anthropic"
@@ -277,7 +414,7 @@ export function ProviderPicker({
(reuse?.provider === row.id && reuse.login === "api-key")
: false;
const savedEndpointKey =
- row?.id === "openai-compatible" &&
+ login === "endpoint" &&
reuseEndpointKey &&
held.saved?.modelApiKeys?.compatible === true &&
baseUrl.trim() === held.OPENAI_BASE_URL?.trim();
@@ -287,6 +424,9 @@ export function ProviderPicker({
// What "done" means differs by the way in, and each is checked before Continue lights up rather
// than after a run fails with something unreadable.
const ready =
+ (login === "oauth" &&
+ oauthSignedIn === row?.id &&
+ model.trim().length > 0) ||
(login === "plan" && (token.trim().length > 0 || savedPlan)) ||
(login === "api-key" && (apiKey.trim().length > 0 || savedApiKey)) ||
/*
@@ -298,7 +438,8 @@ export function ProviderPicker({
(login === "endpoint" &&
isHttpEndpointUrl(baseUrl) &&
containerBaseUrlIsValid &&
- model.trim().length > 0);
+ model.trim().length > 0 &&
+ (!preset || apiKey.trim().length > 0 || savedEndpointKey));
function continueWithChoice() {
if (!row || !login || !ready) return;
@@ -308,19 +449,22 @@ export function ProviderPicker({
const trimmedModel = model.trim();
const trimmedContainerBaseUrl = containerBaseUrl.trim();
onChoose({
- provider: row.id,
+ provider: login === "endpoint" ? "openai-compatible" : row.id,
login,
...((login === "api-key" || login === "endpoint") && trimmedApiKey
? { apiKey: trimmedApiKey }
: {}),
...(login === "plan" && trimmedToken ? { token: trimmedToken } : {}),
+ ...(login === "oauth" ? { saved: true } : {}),
...((login === "plan" && !trimmedToken && savedPlan) ||
(login === "api-key" && !trimmedApiKey && savedApiKey) ||
(login === "endpoint" && !trimmedApiKey && savedEndpointKey)
? { saved: true }
: {}),
- ...(trimmedBaseUrl ? { baseUrl: trimmedBaseUrl } : {}),
- ...(trimmedContainerBaseUrl
+ ...(login !== "oauth" && trimmedBaseUrl
+ ? { baseUrl: trimmedBaseUrl }
+ : {}),
+ ...(login !== "oauth" && trimmedContainerBaseUrl
? { containerBaseUrl: trimmedContainerBaseUrl }
: {}),
...(trimmedModel ? { model: trimmedModel } : {}),
@@ -332,7 +476,7 @@ export function ProviderPicker({
{!returning && <p className="steps-of">Step 3 of 4</p>}
<h1>{returning ? "Refresh your AI connection" : "Connect your AI"}</h1>
<p className="lede">
- Sign in to the plan you already pay for. No key needed.
+ Connect your provider with a supported plan or an API key.
</p>
<fieldset className="picker providers">
@@ -349,6 +493,7 @@ export function ProviderPicker({
value={r.id}
checked={open === r.id}
onChange={() => {
+ if (oauthAttempt.current) void cancelOAuth();
signInRunRef.current += 1;
setOpen(r.id);
// A failure belongs to the row that produced it. Left in place, a refused OpenAI
@@ -369,18 +514,23 @@ export function ProviderPicker({
? held.ANTHROPIC_API_KEY
: undefined;
setApiKey(kept ?? "");
+ const nextPreset = endpointPresets[r.id];
+ const restoreEndpoint =
+ r.id === "openai-compatible" ||
+ (nextPreset &&
+ endpointProvider(held.OPENAI_BASE_URL) === r.id);
setReuseEndpointKey(
- r.id === "openai-compatible" &&
+ Boolean(restoreEndpoint) &&
held.saved?.modelApiKeys?.compatible === true,
);
- if (r.id === "openai-compatible" && held.OPENAI_BASE_URL) {
+ if (restoreEndpoint && held.OPENAI_BASE_URL) {
setBaseUrl(held.OPENAI_BASE_URL);
setContainerBaseUrl(held.OPENAI_CONTAINER_BASE_URL ?? "");
- setModel(held.BOT_MODEL ?? "");
+ setModel(held.BOT_MODEL ?? nextPreset?.model ?? "");
} else {
- setBaseUrl("");
+ setBaseUrl(nextPreset?.baseUrl ?? "");
setContainerBaseUrl("");
- setModel("");
+ setModel(nextPreset?.model ?? "");
}
}}
/>
@@ -402,16 +552,68 @@ export function ProviderPicker({
role="tab"
aria-selected={login === option}
className={login === option ? "on" : ""}
- onClick={() => setLogin(option)}
+ onClick={() => {
+ if (login === "oauth" && option !== login)
+ void cancelOAuth();
+ setLogin(option);
+ }}
>
{option === "plan"
? "Sign in with my plan"
- : "Use an API key"}
+ : option === "oauth"
+ ? "Sign in"
+ : "Use an API key"}
</button>
))}
</div>
)}
+ {login === "oauth" && (
+ <>
+ <p className="footnote">
+ {row.id === "google"
+ ? "Authorize Gemini API access using the configured Google Cloud project and its API quota."
+ : "Authorize OpenBot to use models available to your xAI account."}
+ </p>
+ {oauthSignedIn === row.id ? (
+ <p className="lede">Signed in to {row.name}.</p>
+ ) : signInUrl ? (
+ <>
+ <p role="status">
+ Waiting for you to approve sign-in in your browser.
+ </p>
+ {oauthCode && (
+ <p>
+ Verification code: <strong>{oauthCode}</strong>
+ </p>
+ )}
+ <ExternalLink href={signInUrl}>
+ Open sign-in page
+ </ExternalLink>
+ <button type="button" className="quiet" onClick={cancelOAuth}>
+ Cancel sign-in
+ </button>
+ </>
+ ) : null}
+ {!busy && (
+ <button type="button" onClick={beginOAuth}>
+ Sign in {oauthSignedIn === row.id ? "again " : ""}with{" "}
+ {row.name}
+ </button>
+ )}
+ {busy && !signInUrl && <p role="status">Preparing sign-in…</p>}
+ <div className="field">
+ <label htmlFor="oauth-model">Model name</label>
+ <input
+ id="oauth-model"
+ value={model}
+ onChange={(event) => setModel(event.target.value)}
+ spellCheck={false}
+ />
+ </div>
+ </>
+ )}
+
{login === "plan" &&
(token || (savedPlan && !signInUrl && !busy) ? (
<>
@@ -553,54 +755,60 @@ export function ProviderPicker({
{savedEndpointKey && !apiKey && (
<p className="lede">
A saved API key for this endpoint will be used.{" "}
- <button
- type="button"
- className="quiet"
- onClick={() => setReuseEndpointKey(false)}
- >
- Continue without the saved key
- </button>
+ {!preset && (
+ <button
+ type="button"
+ className="quiet"
+ onClick={() => setReuseEndpointKey(false)}
+ >
+ Continue without the saved key
+ </button>
+ )}
</p>
)}
- <div className="field">
- <label htmlFor="base">Base URL</label>
- <input
- id="base"
- value={baseUrl}
- onChange={(e) => {
- const next = e.target.value;
- setBaseUrl(next);
- if (
- held.OPENAI_CONTAINER_BASE_URL &&
- containerBaseUrl.trim() ===
- held.OPENAI_CONTAINER_BASE_URL.trim() &&
- next.trim() !== held.OPENAI_BASE_URL?.trim()
- ) {
- setContainerBaseUrl("");
- }
- }}
- placeholder="https://…/v1"
- spellCheck={false}
- />
- </div>
- <details className="field">
- <summary>Advanced compatible endpoint options</summary>
- <label htmlFor="container-base">
- Container Base URL, if different
- </label>
- <input
- id="container-base"
- value={containerBaseUrl}
- onChange={(e) => setContainerBaseUrl(e.target.value)}
- placeholder="http://ollama:11434/v1"
- spellCheck={false}
- />
- <p className="footnote">
- Leave this empty unless containers need a different address
- for a locally hosted model. Remote endpoints usually use the
- same Base URL.
- </p>
- </details>
+ {!preset && (
+ <>
+ <div className="field">
+ <label htmlFor="base">Base URL</label>
+ <input
+ id="base"
+ value={baseUrl}
+ onChange={(e) => {
+ const next = e.target.value;
+ setBaseUrl(next);
+ if (
+ held.OPENAI_CONTAINER_BASE_URL &&
+ containerBaseUrl.trim() ===
+ held.OPENAI_CONTAINER_BASE_URL.trim() &&
+ next.trim() !== held.OPENAI_BASE_URL?.trim()
+ ) {
+ setContainerBaseUrl("");
+ }
+ }}
+ placeholder="https://…/v1"
+ spellCheck={false}
+ />
+ </div>
+ <details className="field">
+ <summary>Advanced compatible endpoint options</summary>
+ <label htmlFor="container-base">
+ Container Base URL, if different
+ </label>
+ <input
+ id="container-base"
+ value={containerBaseUrl}
+ onChange={(e) => setContainerBaseUrl(e.target.value)}
+ placeholder="http://ollama:11434/v1"
+ spellCheck={false}
+ />
+ <p className="footnote">
+ Leave this empty unless containers need a different
+ address for a locally hosted model. Remote endpoints
+ usually use the same Base URL.
+ </p>
+ </details>
+ </>
+ )}
<div className="field">
<label htmlFor="model">Model name</label>
<input
@@ -612,7 +820,11 @@ export function ProviderPicker({
/>
</div>
<div className="field">
- <label htmlFor="ekey">API key, if the endpoint needs one</label>
+ <label htmlFor="ekey">
+ {preset
+ ? `${row.name} API key`
+ : "API key, if the endpoint needs one"}
+ </label>
<input
id="ekey"
type="password"
@@ -622,6 +834,13 @@ export function ProviderPicker({
spellCheck={false}
/>
</div>
+ {preset && (
+ <p className="footnote">
+ <ExternalLink key={preset.keyUrl} href={preset.keyUrl}>
+ Get a {row.name} API key
+ </ExternalLink>
+ </p>
+ )}
</>
)}
diff --git a/desktop/src/styles.css b/desktop/src/styles.css
index ed57eb1c..04942074 100644
--- a/desktop/src/styles.css
+++ b/desktop/src/styles.css
@@ -149,6 +149,33 @@ h2 {
margin-top: 1.5rem;
}
+.connection-sheet .row {
+ flex-wrap: wrap;
+}
+
+.connection-form {
+ width: 100%;
+ min-width: 0;
+ border: 0;
+ padding: 0;
+ margin: 0;
+}
+
+.connection-actions {
+ margin-top: 0;
+}
+
+.new-project-form {
+ margin-top: 1rem;
+}
+
+.tile.project-choice {
+ grid-template-columns: minmax(0, 1fr);
+ grid-template-areas: "name";
+ text-align: left;
+ overflow-wrap: anywhere;
+}
+
button {
font: inherit;
font-weight: 500;
@@ -465,26 +492,89 @@ details > summary:hover {
font-size: 0.85rem;
}
+.setup-help {
+ display: inline-block;
+ margin-top: 0.65rem;
+ color: var(--ink-soft);
+ font-size: 0.8rem;
+ text-underline-offset: 2px;
+}
+
+.external-link-error {
+ display: block;
+ margin-top: 0.5rem;
+ color: var(--ink-soft);
+ font-size: 0.8rem;
+ overflow-wrap: anywhere;
+}
+
/* Per-item progress, because this is the slowest screen in the product. */
.steps {
- margin-top: 1.25rem;
+ margin: 1.25rem 0 0;
+ padding: 0;
+ list-style: none;
display: flex;
flex-direction: column;
- gap: 0.3rem;
+ gap: 0.8rem;
}
.step {
display: grid;
- grid-template-columns: 1rem 1fr auto;
- gap: 0.5rem;
+ grid-template-columns: 1rem minmax(0, 1fr) auto;
+ grid-template-areas:
+ "mark label status"
+ ". detail detail";
+ column-gap: 0.5rem;
+ row-gap: 0.15rem;
align-items: baseline;
font-size: 0.82rem;
}
.step .mark {
+ grid-area: mark;
+ align-self: start;
font-size: 0.75rem;
}
+.step-label {
+ grid-area: label;
+}
+
+.step-status {
+ grid-area: status;
+ color: var(--ink-soft);
+ font-size: 0.72rem;
+ text-align: right;
+}
+
+.step-elapsed {
+ font-variant-numeric: tabular-nums;
+ white-space: nowrap;
+}
+
+.step-spinner {
+ display: inline-block;
+ width: 0.85rem;
+ height: 0.85rem;
+ margin-top: 0.2rem;
+ border: 2px solid var(--hair);
+ border-top-color: var(--ink);
+ border-radius: 50%;
+ animation: step-spin 0.8s linear infinite;
+}
+
+@keyframes step-spin {
+ to {
+ transform: rotate(360deg);
+ }
+}
+
+@media (prefers-reduced-motion: reduce) {
+ .step-spinner {
+ animation: none;
+ }
+}
+
.step .mark.good {
color: var(--good);
}
@@ -493,9 +583,24 @@ details > summary:hover {
}
.step .detail {
- color: var(--ink-faint);
+ grid-area: detail;
+ color: var(--ink-soft);
font-size: 0.75rem;
- text-align: right;
+ overflow-wrap: anywhere;
+}
+
+@media (max-width: 580px) {
+ .step {
+ grid-template-columns: 1rem minmax(0, 1fr);
+ grid-template-areas:
+ "mark label"
+ ". status"
+ ". detail";
+ }
+
+ .step-status {
+ text-align: left;
+ }
}
.sr-only {
diff --git a/server/src/app.ts b/server/src/app.ts
index ecfa781c..3bec2d2f 100644
--- a/server/src/app.ts
+++ b/server/src/app.ts
@@ -67,6 +67,10 @@ import {
type PluginStore,
} from "./plugins/store";
import { REFUSAL_MARKER, vendorAnswer } from "./plugins/tools";
+import {
+ type ModelProviderProxy,
+ mountProviderOAuthProxy,
+} from "./provider-oauth";
import { createRoutineRoutes, type RoutineStore } from "./routines/routes";
import type { RoutineRunner } from "./routines/runner";
import type { IntentRouter } from "./routing/classify";
@@ -315,9 +319,12 @@ export function createApp(
* no app directory to offer, rather than one that lists apps nobody can connect.
*/
composio?: { broker: ComposioBroker },
+ /** Native model OAuth stays server-side; callers hold only a separate local bearer. */
+ modelProviderProxy?: ModelProviderProxy,
) {
const app = new Hono<{ Variables: AppVariables }>();
mountDesktopConnectionFailure(app, desktopHostToken);
+ mountProviderOAuthProxy(app, modelProviderProxy);
app.get("/health", (context) => context.json({ status: "ok" }));
// Projected, never the raw runtime. config.runtime carries the Intelligence contract, including
diff --git a/server/src/desktop-connection-failure.ts b/server/src/desktop-connection-failure.ts
index 6b119787..669dbc09 100644
--- a/server/src/desktop-connection-failure.ts
+++ b/server/src/desktop-connection-failure.ts
@@ -43,14 +43,16 @@ export function mountDesktopConnectionFailure<T extends Env>(
});
}
-/** Only provider SDK errors qualify; a harness HTTP 401 is a different credential. */
+/** Only provider SDK errors qualify; a harness HTTP 401 is a different credential.
+ * A provider 403 can mean missing project/resource permission, not expired credentials.
+ */
export function isModelAuthenticationError(error: unknown): boolean {
if (!(error instanceof Error)) return false;
if (error.name === "OpenBotModelAuthenticationError") return true;
if (
error.name === "AI_APICallError" &&
"statusCode" in error &&
- (error.statusCode === 401 || error.statusCode === 403)
+ error.statusCode === 401
)
return true;
return (
diff --git a/server/src/google-oauth-transport.ts b/server/src/google-oauth-transport.ts
new file mode 100644
index 00000000..4a0ce4f9
--- /dev/null
+++ b/server/src/google-oauth-transport.ts
@@ -0,0 +1,456 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+
+// Google's OpenAI endpoint accepts API keys, not the desktop's user OAuth token.
+// Keep the local agents' Chat Completions contract while using the native API.
+const toolCall = z.object({
+ id: z.string(),
+ function: z.object({ name: z.string(), arguments: z.string() }),
+});
+const chat = z.object({
+ model: z.string().regex(/^(?:models\/)?[a-zA-Z0-9._-]+$/),
+ messages: z.array(
+ z.object({
+ role: z.enum(["system", "developer", "user", "assistant", "tool"]),
+ content: z.unknown().optional(),
+ tool_calls: z.array(toolCall).optional(),
+ tool_call_id: z.string().optional(),
+ }),
+ ),
+ tools: z
+ .array(
+ z.object({
+ type: z.literal("function"),
+ function: z.object({
+ name: z.string(),
+ description: z.string().optional(),
+ parameters: z.record(z.string(), z.unknown()).optional(),
+ }),
+ }),
+ )
+ .optional(),
+ tool_choice: z
+ .union([
+ z.enum(["auto", "none", "required"]),
+ z.object({
+ type: z.literal("function"),
+ function: z.object({ name: z.string() }),
+ }),
+ ])
+ .optional(),
+ stream: z.boolean().optional(),
+ stream_options: z
+ .object({ include_usage: z.boolean().optional() })
+ .optional(),
+ temperature: z.number().optional(),
+ top_p: z.number().optional(),
+ max_tokens: z.number().optional(),
+ max_completion_tokens: z.number().optional(),
+ stop: z
+ .union([z.string(), z.array(z.string())])
+ .nullable()
+ .optional(),
+ response_format: z
+ .object({
+ type: z.string(),
+ json_schema: z
+ .object({ schema: z.record(z.string(), z.unknown()) })
+ .optional(),
+ })
+ .optional(),
+});
+const partSchema = z
+ .object({
+ text: z.string().optional(),
+ thought: z.boolean().optional(),
+ thoughtSignature: z.string().optional(),
+ functionCall: z
+ .object({
+ name: z.string(),
+ args: z.record(z.string(), z.unknown()).optional(),
+ id: z.string().optional(),
+ })
+ .optional(),
+ })
+ .passthrough();
+type Part = z.infer<typeof partSchema>;
+type Content = { role: "user" | "model"; parts: Part[] };
+const nativeResponse = z.object({
+ candidates: z
+ .array(
+ z.object({
+ index: z.number().optional(),
+ content: z.object({ parts: z.array(partSchema).optional() }).optional(),
+ finishReason: z.string().optional(),
+ }),
+ )
+ .optional(),
+ usageMetadata: z
+ .object({
+ promptTokenCount: z.number().optional(),
+ candidatesTokenCount: z.number().optional(),
+ thoughtsTokenCount: z.number().optional(),
+ totalTokenCount: z.number().optional(),
+ })
+ .optional(),
+ promptFeedback: z.object({ blockReason: z.string().optional() }).optional(),
+});
+type NativeResponse = z.infer<typeof nativeResponse>;
+
+function parseNative(value: unknown): NativeResponse {
+ if (value && typeof value === "object" && "error" in value)
+ throw new Error("The Google model stream failed.");
+ return nativeResponse.parse(value);
+}
+
+function contentParts(value: unknown): Part[] {
+ if (value == null) return [];
+ if (typeof value === "string") return value ? [{ text: value }] : [];
+ return z
+ .array(
+ z.object({
+ type: z.string(),
+ text: z.string().optional(),
+ image_url: z.object({ url: z.string() }).optional(),
+ }),
+ )
+ .parse(value)
+ .map((part) => {
+ if (part.type === "text" && part.text !== undefined)
+ return { text: part.text };
+ if (part.type === "image_url" && part.image_url) {
+ const data =
+ /^data:(image\/[a-zA-Z0-9.+-]+);base64,([A-Za-z0-9+/=\s]+)$/.exec(
+ part.image_url.url,
+ );
+ if (data) return { inlineData: { mimeType: data[1], data: data[2] } };
+ const url = new URL(part.image_url.url);
+ if (url.protocol !== "https:") throw new Error("Unsupported image URL");
+ return { fileData: { fileUri: url.href } };
+ }
+ throw new Error("Unsupported model content");
+ });
+}
+
+// Match LiteLLM's maintained OpenAI-client compatibility technique: only the
+// opaque signature travels in the ID, never model text or tool arguments.
+// https://github.com/BerriAI/litellm/blob/main/litellm/litellm_core_utils/prompt_templates/factory.py
+const signatureSeparator = "__thought__";
+
+export function googleRequest(input: unknown) {
+ const request = chat.parse(input);
+ const contents: Content[] = [];
+ const system: Part[] = [];
+ const calls = new Map<string, { name: string; id?: string }>();
+ for (const message of request.messages) {
+ let parts = contentParts(message.content);
+ if (message.role === "system" || message.role === "developer") {
+ if (parts.some((part) => part.text === undefined))
+ throw new Error("System instructions must be text");
+ system.push(...parts);
+ continue;
+ }
+ if (message.role === "assistant" && message.tool_calls?.length) {
+ const generated = message.tool_calls.map((call) => {
+ const args = z
+ .record(z.string(), z.unknown())
+ .parse(JSON.parse(call.function.arguments));
+ const separator = call.id.indexOf(signatureSeparator);
+ const cleanId = separator < 0 ? call.id : call.id.slice(0, separator);
+ const signature =
+ separator < 0
+ ? undefined
+ : call.id.slice(separator + signatureSeparator.length);
+ const id = /^(?:models\/)?gemini-3/.test(request.model)
+ ? cleanId
+ : undefined;
+ calls.set(call.id, { name: call.function.name, id });
+ return {
+ functionCall: {
+ name: call.function.name,
+ args,
+ ...(id ? { id } : {}),
+ },
+ ...(signature ? { thoughtSignature: signature } : {}),
+ };
+ });
+ parts.push(...generated);
+ }
+ if (message.role === "tool") {
+ const call = calls.get(message.tool_call_id ?? "");
+ if (!call) throw new Error("Tool result has no matching call");
+ const text = parts
+ .flatMap((part) => (part.text === undefined ? [] : [part.text]))
+ .join("\n");
+ const images = parts.filter((part) => part.inlineData !== undefined);
+ if (parts.some((part) => part.fileData !== undefined))
+ throw new Error("Tool images must use inline data");
+ let result: unknown = text;
+ try {
+ result = JSON.parse(text);
+ } catch {
+ /* Plain text tool output is valid. */
+ }
+ parts = [
+ {
+ functionResponse: {
+ ...call,
+ response: { result },
+ ...(images.length ? { parts: images } : {}),
+ },
+ },
+ ];
+ }
+ if (!parts.length) continue;
+ const role = message.role === "assistant" ? "model" : "user";
+ const previous = contents.at(-1);
+ if (previous?.role === role) previous.parts.push(...parts);
+ else contents.push({ role, parts });
+ }
+ const generationConfig: Record<string, unknown> = {};
+ if (request.temperature !== undefined)
+ generationConfig.temperature = request.temperature;
+ if (request.top_p !== undefined) generationConfig.topP = request.top_p;
+ if (
+ request.max_completion_tokens !== undefined ||
+ request.max_tokens !== undefined
+ )
+ generationConfig.maxOutputTokens =
+ request.max_completion_tokens ?? request.max_tokens;
+ if (request.stop)
+ generationConfig.stopSequences =
+ typeof request.stop === "string" ? [request.stop] : request.stop;
+ if (
+ request.response_format?.type === "json_object" ||
+ request.response_format?.type === "json_schema"
+ ) {
+ generationConfig.responseMimeType = "application/json";
+ if (request.response_format.json_schema)
+ generationConfig.responseJsonSchema =
+ request.response_format.json_schema.schema;
+ }
+ const choice = request.tool_choice;
+ const model = request.model.replace(/^models\//, "");
+ return {
+ model,
+ stream: request.stream === true,
+ includeUsage: request.stream_options?.include_usage === true,
+ url: `https://generativelanguage.googleapis.com/v1beta/models/${model}:${request.stream ? "streamGenerateContent?alt=sse" : "generateContent"}`,
+ body: {
+ contents,
+ ...(system.length ? { systemInstruction: { parts: system } } : {}),
+ ...(Object.keys(generationConfig).length ? { generationConfig } : {}),
+ ...(request.tools?.length
+ ? {
+ tools: [
+ {
+ functionDeclarations: request.tools.map(({ function: fn }) => ({
+ name: fn.name,
+ ...(fn.description ? { description: fn.description } : {}),
+ ...(fn.parameters
+ ? { parametersJsonSchema: fn.parameters }
+ : {}),
+ })),
+ },
+ ],
+ }
+ : {}),
+ ...(choice
+ ? {
+ toolConfig: {
+ functionCallingConfig:
+ typeof choice === "object"
+ ? {
+ mode: "ANY",
+ allowedFunctionNames: [choice.function.name],
+ }
+ : {
+ mode: { auto: "AUTO", none: "NONE", required: "ANY" }[
+ choice
+ ],
+ },
+ },
+ }
+ : {}),
+ },
+ };
+}
+
+function usage(metadata: NativeResponse["usageMetadata"]) {
+ if (!metadata) return undefined;
+ const prompt = metadata.promptTokenCount ?? 0;
+ const completion =
+ (metadata.candidatesTokenCount ?? 0) + (metadata.thoughtsTokenCount ?? 0);
+ return {
+ prompt_tokens: prompt,
+ completion_tokens: completion,
+ total_tokens: metadata.totalTokenCount ?? prompt + completion,
+ completion_tokens_details: {
+ reasoning_tokens: metadata.thoughtsTokenCount ?? 0,
+ },
+ };
+}
+
+function finishReason(reason: string | undefined, hasCalls: boolean): string {
+ if (reason === "MAX_TOKENS") return "length";
+ if (reason && reason !== "STOP") return "content_filter";
+ return hasCalls ? "tool_calls" : "stop";
+}
+
+function outputCalls(parts: Part[]) {
+ return parts
+ .flatMap((part) =>
+ part.functionCall ? [{ part, fn: part.functionCall }] : [],
+ )
+ .map(({ part, fn }) => ({
+ id: `${fn.id ?? `call_${randomUUID().replaceAll("-", "")}`}${part.thoughtSignature ? `${signatureSeparator}${part.thoughtSignature}` : ""}`,
+ type: "function" as const,
+ function: { name: fn.name, arguments: JSON.stringify(fn.args ?? {}) },
+ }));
+}
+
+/** Transform only successful native responses; the caller handles auth and errors. */
+export async function googleResponse(
+ response: Response,
+ model: string,
+ stream: boolean,
+ includeUsage = false,
+): Promise<Response> {
+ const id = `chatcmpl-${randomUUID()}`;
+ const created = Math.floor(Date.now() / 1000);
+ const headers = {
+ "content-type": stream ? "text/event-stream" : "application/json",
+ "cache-control": "no-store",
+ };
+ if (!stream) {
+ const native = parseNative(await response.json());
+ const candidate = native.candidates?.[0];
+ const parts = candidate?.content?.parts ?? [];
+ const calls = outputCalls(parts);
+ return Response.json(
+ {
+ id,
+ object: "chat.completion",
+ created,
+ model,
+ choices: [
+ {
+ index: 0,
+ message: {
+ role: "assistant",
+ content:
+ parts
+ .filter((part) => !part.thought)
+ .map((part) => part.text ?? "")
+ .join("") || null,
+ ...(calls.length ? { tool_calls: calls } : {}),
+ extra_content: { google: { parts } },
+ },
+ finish_reason: finishReason(
+ candidate?.finishReason ?? native.promptFeedback?.blockReason,
+ calls.length > 0,
+ ),
+ },
+ ],
+ usage: usage(native.usageMetadata),
+ },
+ { headers },
+ );
+ }
+ if (!response.body) throw new Error("Gemini returned no stream");
+ let buffer = "";
+ let data: string[] = [];
+ const parts: Part[] = [];
+ let metadata: NativeResponse["usageMetadata"];
+ let reason: string | undefined;
+ let began = false;
+ let failed = false;
+ const encode = new TextEncoder();
+ const fail = (controller: TransformStreamDefaultController<Uint8Array>) => {
+ if (failed) return;
+ failed = true;
+ controller.enqueue(
+ encode.encode(
+ `data: ${JSON.stringify({ error: { message: "The Google model stream failed or ended early. Try again.", type: "provider_error", code: "incomplete_model_stream" } })}\n\n`,
+ ),
+ );
+ };
+ const send = (
+ controller: TransformStreamDefaultController<Uint8Array>,
+ delta: Record<string, unknown>,
+ finish: string | null = null,
+ ) => {
+ controller.enqueue(
+ encode.encode(
+ `data: ${JSON.stringify({ id, object: "chat.completion.chunk", created, model, choices: [{ index: 0, delta, finish_reason: finish }] })}\n\n`,
+ ),
+ );
+ };
+ const frame = (controller: TransformStreamDefaultController<Uint8Array>) => {
+ if (!data.length) return;
+ const json = data.join("\n");
+ data = [];
+ if (json === "[DONE]") return;
+ let native: NativeResponse;
+ try {
+ native = parseNative(JSON.parse(json));
+ } catch {
+ fail(controller);
+ return;
+ }
+ if (!began) {
+ send(controller, { role: "assistant", content: "" });
+ began = true;
+ }
+ const candidate = native.candidates?.[0];
+ for (const part of candidate?.content?.parts ?? []) {
+ parts.push(part);
+ if (part.text && !part.thought) send(controller, { content: part.text });
+ }
+ metadata = native.usageMetadata ?? metadata;
+ reason =
+ candidate?.finishReason ?? native.promptFeedback?.blockReason ?? reason;
+ };
+ const transformed = response.body
+ .pipeThrough(new TextDecoderStream())
+ .pipeThrough(
+ new TransformStream<string, Uint8Array>({
+ transform(chunk, controller) {
+ if (failed) return;
+ buffer += chunk;
+ let newline = buffer.indexOf("\n");
+ while (newline >= 0) {
+ const line = buffer.slice(0, newline).replace(/\r$/, "");
+ buffer = buffer.slice(newline + 1);
+ if (!line) frame(controller);
+ else if (line.startsWith("data:"))
+ data.push(line.slice(5).replace(/^ /, ""));
+ else if (!/^(?::|event:|id:|retry:)/.test(line)) fail(controller);
+ if (failed) return;
+ newline = buffer.indexOf("\n");
+ }
+ },
+ flush(controller) {
+ if (failed) return;
+ if (buffer.trim() || data.length || !reason) {
+ fail(controller);
+ return;
+ }
+ const calls = outputCalls(parts);
+ if (calls.length)
+ send(controller, {
+ tool_calls: calls.map((call, index) => ({ index, ...call })),
+ });
+ send(controller, {}, finishReason(reason, calls.length > 0));
+ if (includeUsage && metadata)
+ controller.enqueue(
+ encode.encode(
+ `data: ${JSON.stringify({ id, object: "chat.completion.chunk", created, model, choices: [], usage: usage(metadata) })}\n\n`,
+ ),
+ );
+ controller.enqueue(encode.encode("data: [DONE]\n\n"));
+ },
+ }),
+ );
+ return new Response(transformed, { headers });
+}
diff --git a/server/src/index.ts b/server/src/index.ts
index b6d641ff..47065bea 100644
--- a/server/src/index.ts
+++ b/server/src/index.ts
@@ -90,6 +90,7 @@ import { hostAccessTools } from "./host-access/tools";
import { observeIntelligenceAuthentication } from "./intelligence-client";
import { createOnboardingStore } from "./people/onboarding";
import { createPeopleStore } from "./people/store";
+import { createProviderOAuthProxy } from "./provider-oauth";
import { useRoutineTools } from "./plugins/builtin-routines";
import { useComposioClient } from "./plugins/composio";
import { createComposioClient } from "./plugins/composio-adapter";
@@ -1309,6 +1310,9 @@ const app = createApp(
// Absent without a key, which leaves the routes reporting no broker rather than listing apps
// nobody could connect.
composio ? { broker: composio.broker } : undefined,
+ process.env.OPENBOT_MODEL_OAUTH_FILE?.trim()
+ ? createProviderOAuthProxy(process.env.OPENBOT_MODEL_OAUTH_FILE.trim())
+ : undefined,
);
/**
diff --git a/server/src/provider-oauth-lock.ts b/server/src/provider-oauth-lock.ts
new file mode 100644
index 00000000..a27c6226
--- /dev/null
+++ b/server/src/provider-oauth-lock.ts
@@ -0,0 +1,176 @@
+import { constants } from "node:fs";
+import { lstat, mkdir, open } from "node:fs/promises";
+import { join } from "node:path";
+
+export class CredentialLockUnavailable extends Error {}
+
+// Both writers keep this directory and inode permanently. Never remove a held lock:
+// another opener could then lock a different inode. Empty legacy directories work too.
+export async function lockProviderCredentials(
+ file: string,
+): Promise<() => Promise<void>> {
+ try {
+ const directory = `${file}.lock`;
+ await mkdir(directory, { mode: 0o700 }).catch((error: unknown) => {
+ if (
+ !(error instanceof Error && "code" in error && error.code === "EEXIST")
+ )
+ throw error;
+ });
+ const info = await lstat(directory);
+ // Legacy native mkdir could leave 0755; only its owner can change entries.
+ // The stable lock file itself must still be 0600.
+ if (
+ !info.isDirectory() ||
+ info.isSymbolicLink() ||
+ (process.platform !== "win32" && (info.mode & 0o022) !== 0)
+ )
+ throw new Error("The credential lock directory is not private.");
+ const path = join(directory, "owner.lock");
+ return process.platform === "win32"
+ ? await windowsLock(path)
+ : await unixLock(path);
+ } catch {
+ throw new CredentialLockUnavailable(
+ "The model credential store is busy or unavailable.",
+ );
+ }
+}
+
+async function unixLock(path: string): Promise<() => Promise<void>> {
+ const ffi = await import("bun:ffi");
+ const mac = process.platform === "darwin";
+ const library = ffi.dlopen(mac ? "/usr/lib/libSystem.B.dylib" : "libc.so.6", {
+ flock: { args: ["i32", "i32"], returns: "i32" },
+ [mac ? "__error" : "__errno_location"]: { args: [], returns: "ptr" },
+ });
+ const handle = await open(
+ path,
+ constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW,
+ 0o600,
+ ).catch((error: unknown) => {
+ library.close();
+ throw error;
+ });
+ try {
+ const info = await handle.stat();
+ if (!info.isFile() || (info.mode & 0o077) !== 0)
+ throw new Error("Invalid credential lock file.");
+ const deadline = Date.now() + 5000;
+ while (library.symbols.flock(handle.fd, 2 | 4) !== 0) {
+ // LOCK_EX | LOCK_NB
+ const address = library.symbols[mac ? "__error" : "__errno_location"]();
+ if (
+ !address ||
+ ffi.read.i32(address) !== (mac ? 35 : 11) ||
+ Date.now() >= deadline
+ )
+ throw new Error("Could not acquire credential lock.");
+ await Bun.sleep(25);
+ }
+ return async () => {
+ // Closing releases flock even if this process is killed before explicit cleanup.
+ try {
+ await handle.close();
+ } finally {
+ library.close();
+ }
+ };
+ } catch (error) {
+ try {
+ await handle.close();
+ } finally {
+ library.close();
+ }
+ throw error;
+ }
+}
+
+// Bun 1.3 has no Windows ARM64 FFI. Windows PowerShell ships with the OS and
+// owns the same share-mode lock as Rust. EOF on this pipe also releases it when
+// the Bun parent dies. The path is environment data, never interpolated code.
+const windowsLockScript = `
+$ErrorActionPreference='Stop'
+Add-Type -TypeDefinition @'
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
+public static class OpenBotCredentialLock {
+ [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)]
+ static extern SafeFileHandle CreateFileW(string path, uint access, uint share, IntPtr security, uint creation, uint flags, IntPtr template);
+ [DllImport("kernel32.dll", SetLastError=true)]
+ static extern bool GetFileInformationByHandleEx(SafeFileHandle file, int kind, out TagInfo info, uint size);
+ [StructLayout(LayoutKind.Sequential)] struct TagInfo { public uint Attributes; public uint Tag; }
+ public static SafeFileHandle Open(string path) {
+ var file = CreateFileW(path, 0xC0000000, 0, IntPtr.Zero, 4, 0x00200000, IntPtr.Zero);
+ if (file.IsInvalid) { int error = Marshal.GetLastWin32Error(); file.Dispose(); throw new Win32Exception(error); }
+ TagInfo info;
+ if (!GetFileInformationByHandleEx(file, 9, out info, 8) || (info.Attributes & 0x410) != 0) {
+ file.Dispose(); throw new InvalidOperationException("Invalid credential lock file.");
+ }
+ return file;
+ }
+}
+'@
+$deadline=[DateTime]::UtcNow.AddSeconds(5)
+$file=$null
+while ($null -eq $file) {
+ try { $file=[OpenBotCredentialLock]::Open($env:OPENBOT_CREDENTIAL_LOCK) }
+ catch {
+ $cause=$_.Exception.GetBaseException()
+ if ($cause -isnot [System.ComponentModel.Win32Exception] -or $cause.NativeErrorCode -ne 32 -or [DateTime]::UtcNow -ge $deadline) { exit 1 }
+ Start-Sleep -Milliseconds 25
+ }
+}
+try { [Console]::Out.WriteLine('locked'); [Console]::Out.Flush(); [Console]::In.ReadLine() | Out-Null }
+finally { $file.Dispose() }
+`;
+
+async function windowsLock(path: string): Promise<() => Promise<void>> {
+ const env: NodeJS.ProcessEnv = {
+ ...process.env,
+ OPENBOT_CREDENTIAL_LOCK: path,
+ };
+ delete env.PSModulePath;
+ const child = Bun.spawn(
+ [
+ "powershell.exe",
+ "-NoProfile",
+ "-NonInteractive",
+ "-Command",
+ windowsLockScript,
+ ],
+ {
+ env,
+ stdin: "pipe",
+ stdout: "pipe",
+ stderr: "ignore",
+ windowsHide: true,
+ },
+ );
+ const reader = child.stdout.getReader();
+ const timeout = setTimeout(() => child.kill(), 15_000);
+ try {
+ let message = "";
+ while (!message.includes("\n")) {
+ const { value, done } = await reader.read();
+ if (done) throw new Error("Could not acquire credential lock.");
+ message += new TextDecoder().decode(value);
+ }
+ if (message.trim() !== "locked")
+ throw new Error("Invalid credential lock response.");
+ } catch (error) {
+ child.kill();
+ await child.exited;
+ throw error;
+ } finally {
+ clearTimeout(timeout);
+ reader.releaseLock();
+ }
+ return async () => {
+ child.stdin.end();
+ if ((await child.exited) !== 0)
+ throw new Error("Could not release credential lock.");
+ };
+}
diff --git a/server/src/provider-oauth.ts b/server/src/provider-oauth.ts
new file mode 100644
index 00000000..75d48cd5
--- /dev/null
+++ b/server/src/provider-oauth.ts
@@ -0,0 +1,344 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, open, rename, unlink } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import type { Env, Hono } from "hono";
+import { z } from "zod";
+import { sameToken } from "./agents/callback-token";
+import {
+ clearDesktopConnectionFailure,
+ recordDesktopConnectionFailure,
+} from "./desktop-connection-failure";
+import { googleRequest, googleResponse } from "./google-oauth-transport";
+import {
+ CredentialLockUnavailable,
+ lockProviderCredentials,
+} from "./provider-oauth-lock";
+
+export type ModelOAuthRecord = {
+ version: 1;
+ sessionId: string;
+ provider: "google" | "xai";
+ clientId: string;
+ clientSecret?: string;
+ accessToken: string;
+ refreshToken: string;
+ expiresAt: number;
+ scope: string;
+ quotaProject?: string;
+ proxyToken: string;
+};
+
+type Fetch = (
+ input: RequestInfo | URL,
+ init?: RequestInit,
+) => Promise<Response>;
+export type ModelProviderProxy = (request: Request) => Promise<Response>;
+
+const schema = z.object({
+ version: z.literal(1),
+ sessionId: z.string().min(1),
+ provider: z.enum(["google", "xai"]),
+ clientId: z.string().min(1),
+ clientSecret: z.string().optional(),
+ accessToken: z.string().min(1),
+ refreshToken: z.string().min(1),
+ expiresAt: z.number().finite().positive(),
+ scope: z.string(),
+ quotaProject: z.string().min(1).optional(),
+ proxyToken: z.string().min(1),
+});
+
+const providers = {
+ google: {
+ token: "https://oauth2.googleapis.com/token",
+ },
+ xai: {
+ token: "https://auth.x.ai/oauth2/token",
+ chat: "https://api.x.ai/v1/chat/completions",
+ },
+};
+
+class SignInRequired extends Error {}
+
+async function readRecord(file: string): Promise<ModelOAuthRecord> {
+ // Windows ignores O_NOFOLLOW. Bind its no-follow path metadata to the opened
+ // handle before reading bytes, so a replacement between lstat/open is refused.
+ const before =
+ process.platform === "win32"
+ ? await lstat(file, { bigint: true })
+ : undefined;
+ if (before && (!before.isFile() || before.ino === 0n))
+ throw new Error("The private model credential path is not valid.");
+ const handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+ try {
+ const info = await handle.stat({ bigint: true });
+ if (before && (before.dev !== info.dev || before.ino !== info.ino))
+ throw new Error(
+ "The private model credential path changed while opening.",
+ );
+ if (
+ !info.isFile() ||
+ info.size > 64n * 1024n ||
+ (process.platform !== "win32" && (info.mode & 0o077n) !== 0n)
+ )
+ throw new Error("The private model credential file is not valid.");
+ const record = schema.parse(JSON.parse(await handle.readFile("utf8")));
+ if (record.provider === "google" && !record.quotaProject)
+ throw new Error("The Google model quota project is missing.");
+ return record;
+ } finally {
+ await handle.close();
+ }
+}
+
+function hasCode(error: unknown, code: string): boolean {
+ return error instanceof Error && "code" in error && error.code === code;
+}
+
+/** Native sign-in uses the same lock. A new session must win over an older refresh. */
+async function persistRotation(
+ file: string,
+ previous: ModelOAuthRecord,
+ next: ModelOAuthRecord,
+): Promise<void> {
+ const temporary = `${file}.${randomUUID()}.tmp`;
+ try {
+ const current = await readRecord(file);
+ if (
+ current.sessionId !== previous.sessionId ||
+ current.refreshToken !== previous.refreshToken
+ )
+ throw new SignInRequired("The model sign-in changed during refresh.");
+ const handle = await open(temporary, "wx", 0o600);
+ try {
+ await handle.writeFile(JSON.stringify(next));
+ await handle.sync();
+ } finally {
+ await handle.close();
+ }
+ await rename(temporary, file);
+ } finally {
+ await unlink(temporary).catch((error: unknown) => {
+ if (!hasCode(error, "ENOENT")) throw error;
+ });
+ }
+}
+
+function refused(status: number, error: string): Response {
+ return Response.json(
+ { error },
+ { status, headers: { "cache-control": "no-store" } },
+ );
+}
+
+/** One host-server instance owns refresh; agents use only its separate local bearer. */
+export function createProviderOAuthProxy(
+ file: string,
+ options: { fetch?: Fetch } = {},
+): ModelProviderProxy {
+ if (!isAbsolute(file))
+ throw new Error("The model OAuth file must be absolute.");
+ const requestProvider = options.fetch ?? fetch;
+ const refreshes = new Map<string, Promise<ModelOAuthRecord>>();
+
+ async function refresh(
+ previous: ModelOAuthRecord,
+ ): Promise<ModelOAuthRecord> {
+ const pending = refreshes.get(previous.sessionId);
+ if (pending) return pending;
+ const work = (async () => {
+ const unlock = await lockProviderCredentials(file);
+ try {
+ const current = await readRecord(file);
+ if (current.sessionId !== previous.sessionId)
+ throw new SignInRequired("The model sign-in changed.");
+ // A concurrent request may have already rotated the token that received a 401.
+ if (current.accessToken !== previous.accessToken) return current;
+ const body = new URLSearchParams({
+ grant_type: "refresh_token",
+ client_id: current.clientId,
+ refresh_token: current.refreshToken,
+ });
+ if (current.clientSecret)
+ body.set("client_secret", current.clientSecret);
+ const response = await requestProvider(
+ providers[current.provider].token,
+ {
+ method: "POST",
+ redirect: "error",
+ signal: AbortSignal.timeout(15_000),
+ headers: {
+ "content-type": "application/x-www-form-urlencoded",
+ accept: "application/json",
+ },
+ body,
+ },
+ );
+ if (!response.ok) {
+ await response.body?.cancel();
+ throw new SignInRequired("The model provider refused token refresh.");
+ }
+ const tokens = z
+ .object({
+ access_token: z.string().min(1),
+ refresh_token: z.string().min(1).optional(),
+ expires_in: z.number().finite().positive().optional(),
+ token_type: z.string().optional(),
+ })
+ .parse(await response.json());
+ if (tokens.token_type && tokens.token_type.toLowerCase() !== "bearer")
+ throw new SignInRequired(
+ "The model provider returned an unsupported token.",
+ );
+ const next = {
+ ...current,
+ accessToken: tokens.access_token,
+ refreshToken: tokens.refresh_token ?? current.refreshToken,
+ expiresAt: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+ };
+ // Do not use a rotated pair until it is durable; a failed save requires sign-in again.
+ await persistRotation(file, current, next);
+ return next;
+ } finally {
+ await unlock();
+ }
+ })();
+ refreshes.set(previous.sessionId, work);
+ try {
+ return await work;
+ } finally {
+ refreshes.delete(previous.sessionId);
+ }
+ }
+
+ return async (request) => {
+ let current: ModelOAuthRecord;
+ try {
+ current = await readRecord(file);
+ } catch {
+ return refused(
+ 503,
+ "The local model sign-in is unavailable. Sign in again.",
+ );
+ }
+ const offered = request.headers.get("authorization") ?? "";
+ if (!sameToken(offered, `Bearer ${current.proxyToken}`))
+ return refused(401, "The local model proxy requires authentication.");
+
+ let body: ArrayBuffer;
+ try {
+ body = await request.arrayBuffer();
+ } catch {
+ return refused(400, "The model request body could not be read.");
+ }
+ try {
+ if (current.expiresAt <= Date.now() + 120_000)
+ current = await refresh(current);
+ } catch (error) {
+ if (error instanceof CredentialLockUnavailable)
+ return refused(
+ 503,
+ "The model credential store is busy or unavailable. Try again.",
+ );
+ recordDesktopConnectionFailure({
+ connection: "model",
+ code: "provider_authentication_failed",
+ });
+ return refused(
+ 401,
+ "The model sign-in could not be refreshed. Sign in again.",
+ );
+ }
+
+ let google: ReturnType<typeof googleRequest> | undefined;
+ if (current.provider === "google") {
+ try {
+ google = googleRequest(JSON.parse(new TextDecoder().decode(body)));
+ } catch {
+ return refused(
+ 400,
+ "The Google model request has unsupported or invalid content.",
+ );
+ }
+ }
+
+ const send = (credential: ModelOAuthRecord) => {
+ const headers = new Headers({
+ "content-type": "application/json",
+ authorization: `Bearer ${credential.accessToken}`,
+ });
+ if (credential.provider === "google" && credential.quotaProject)
+ headers.set("x-goog-user-project", credential.quotaProject);
+ return requestProvider(google?.url ?? providers.xai.chat, {
+ method: "POST",
+ headers,
+ body: google ? JSON.stringify(google.body) : body,
+ redirect: "error",
+ signal: request.signal,
+ });
+ };
+ try {
+ let response = await send(current);
+ if (response.status === 401) {
+ await response.body?.cancel();
+ try {
+ current = await refresh(current);
+ } catch (error) {
+ if (error instanceof CredentialLockUnavailable) throw error;
+ throw new SignInRequired("The model sign-in could not be refreshed.");
+ }
+ response = await send(current);
+ }
+ if (!response.ok) {
+ await response.body?.cancel();
+ if (response.status === 401)
+ throw new SignInRequired("The model provider refused this sign-in.");
+ return refused(
+ response.status >= 400 ? response.status : 502,
+ `The model provider rejected the request (HTTP ${response.status}).`,
+ );
+ }
+ clearDesktopConnectionFailure("model");
+ if (google)
+ return await googleResponse(
+ response,
+ google.model,
+ google.stream,
+ google.includeUsage,
+ );
+ return new Response(response.body, {
+ status: response.status,
+ headers: {
+ "content-type":
+ response.headers.get("content-type") ?? "application/json",
+ "cache-control": "no-store",
+ },
+ });
+ } catch (error) {
+ if (error instanceof CredentialLockUnavailable)
+ return refused(
+ 503,
+ "The model credential store is busy or unavailable. Try again.",
+ );
+ if (error instanceof SignInRequired) {
+ recordDesktopConnectionFailure({
+ connection: "model",
+ code: "provider_authentication_failed",
+ });
+ return refused(401, "The model provider needs you to sign in again.");
+ }
+ return refused(502, "The model provider could not be reached.");
+ }
+ };
+}
+
+export function mountProviderOAuthProxy<T extends Env>(
+ app: Hono<T>,
+ proxy: ModelProviderProxy | undefined,
+): void {
+ if (proxy)
+ app.post("/api/model-provider/v1/chat/completions", (context) =>
+ proxy(context.req.raw),
+ );
+}
diff --git a/server/tests/desktop-connection-failure.test.ts b/server/tests/desktop-connection-failure.test.ts
index 15ec78f1..ad5cbef1 100644
--- a/server/tests/desktop-connection-failure.test.ts
+++ b/server/tests/desktop-connection-failure.test.ts
@@ -1,7 +1,7 @@
import { afterEach, expect, test } from "bun:test";
import { EventType } from "@ag-ui/client";
import { Hono } from "hono";
-import { firstValueFrom, of } from "rxjs";
+import { firstValueFrom, of, throwError } from "rxjs";
import {
clearDesktopConnectionFailure,
isModelAuthenticationError,
@@ -74,30 +74,78 @@ test("typed provider failures trigger refresh and successful model output clears
});
});
+function providerError(statusCode: number, cause?: Error) {
+ return Object.assign(
+ new Error("provider detail must not enter native status", { cause }),
+ {
+ name: "AI_APICallError",
+ statusCode,
+ },
+ );
+}
+
+function explicitAuthenticationError() {
+ return Object.assign(new Error("provider authentication failed"), {
+ name: "OpenBotModelAuthenticationError",
+ });
+}
+
test("HTTP status and error prose from unrelated services are not model authentication", () => {
expect(
isModelAuthenticationError(
Object.assign(new Error("401 model unauthorized"), { statusCode: 401 }),
),
).toBe(false);
- for (const statusCode of [400, 404, 429, 500]) {
+ for (const statusCode of [400, 403, 404, 429, 500]) {
+ const error = providerError(statusCode);
+ expect(isModelAuthenticationError(error)).toBe(false);
expect(
isModelAuthenticationError(
- Object.assign(new Error("provider issue"), {
- name: "AI_APICallError",
- statusCode,
- }),
+ new Error("wrapped provider issue", { cause: error }),
),
).toBe(false);
}
- for (const statusCode of [401, 403]) {
+});
+
+test("provider 401 and explicit authentication markers survive SDK wrapping", () => {
+ for (const error of [providerError(401), explicitAuthenticationError()]) {
+ expect(isModelAuthenticationError(error)).toBe(true);
expect(
isModelAuthenticationError(
- Object.assign(new Error("provider issue"), {
- name: "AI_APICallError",
- statusCode,
- }),
+ new Error("wrapped provider issue", { cause: error }),
),
).toBe(true);
}
+ expect(
+ isModelAuthenticationError(
+ providerError(403, explicitAuthenticationError()),
+ ),
+ ).toBe(true);
});
+
+test.each([
+ ["provider 403 permission denial", providerError(403), false],
+ [
+ "wrapped provider 403 permission denial",
+ new Error("wrapped provider issue", { cause: providerError(403) }),
+ false,
+ ],
+ ["provider 401 invalid credentials", providerError(401), true],
+ ["explicit authentication failure", explicitAuthenticationError(), true],
+] as const)(
+ "model observation preserves %s without guessing authentication",
+ async (_label, error, requiresAuthentication) => {
+ const { read } = endpoint();
+ await expect(
+ firstValueFrom(observeModelConnection(throwError(() => error))),
+ ).rejects.toBe(error);
+ expect(await (await read()).json()).toEqual(
+ requiresAuthentication
+ ? {
+ connection: "model",
+ code: "provider_authentication_failed",
+ }
+ : null,
+ );
+ },
+);
diff --git a/server/tests/fixtures/provider-oauth-lock-cross-process.ts b/server/tests/fixtures/provider-oauth-lock-cross-process.ts
new file mode 100644
index 00000000..e41aae01
--- /dev/null
+++ b/server/tests/fixtures/provider-oauth-lock-cross-process.ts
@@ -0,0 +1,102 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+ CredentialLockUnavailable,
+ lockProviderCredentials,
+} from "../../src/provider-oauth-lock";
+
+// Runs the exact production Bun and Rust lock helpers in both directions.
+const native = process.argv[2];
+if (!native) throw new Error("Native lock-owner executable is required.");
+const root = await mkdtemp(join(tmpdir(), "openbot-cross-writer-"));
+const file = join(root, "model-oauth.json");
+const children: ReturnType<typeof holder>[] = [];
+function holder(command: string[]) {
+ const child = Bun.spawn(command, {
+ stdin: "pipe",
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ let acquired = false;
+ const ready = (async () => {
+ const reader = child.stdout.getReader();
+ const timeout = setTimeout(() => child.kill(), 15000);
+ try {
+ let output = "";
+ while (!output.includes("\n")) {
+ const { done, value } = await reader.read();
+ if (done)
+ throw new Error(
+ `Lock owner exited: ${await new Response(child.stderr).text()}`,
+ );
+ output += new TextDecoder().decode(value);
+ }
+ if (output.trim() !== "locked")
+ throw new Error(`Unexpected readiness: ${output}`);
+ acquired = true;
+ } finally {
+ reader.releaseLock();
+ clearTimeout(timeout);
+ }
+ })();
+ return { child, ready, acquired: () => acquired };
+}
+try {
+ const nativeFirst = holder([native, file]);
+ children.push(nativeFirst);
+ await nativeFirst.ready;
+ const started = performance.now();
+ try {
+ const unexpectedRelease = await lockProviderCredentials(file);
+ await unexpectedRelease();
+ throw new Error("Bun entered a live native lock.");
+ } catch (error) {
+ if (!(error instanceof CredentialLockUnavailable)) throw error;
+ }
+ const blockedMs = performance.now() - started;
+ if (blockedMs < 4900)
+ throw new Error(
+ `Lock failure preceded the acquisition timeout: ${blockedMs}ms`,
+ );
+ if (nativeFirst.child.exitCode !== null)
+ throw new Error(
+ "Native owner exited before the blocked attempt completed.",
+ );
+ nativeFirst.child.kill("SIGKILL");
+ await nativeFirst.child.exited;
+ const release = await lockProviderCredentials(file);
+ await release();
+ console.log(
+ `PASS native owner excludes Bun for the full timeout (${Math.round(blockedMs)}ms); killing native permits Bun acquisition`,
+ );
+
+ const bunFirst = holder([
+ process.execPath,
+ fileURLToPath(new URL("./provider-oauth-lock-owner.ts", import.meta.url)),
+ file,
+ ]);
+ children.push(bunFirst);
+ await bunFirst.ready;
+ const pendingNative = holder([native, file]);
+ children.push(pendingNative);
+ await Bun.sleep(200);
+ if (pendingNative.acquired())
+ throw new Error("Native entered a live Bun lock.");
+ bunFirst.child.kill("SIGKILL");
+ await bunFirst.child.exited;
+ await pendingNative.ready;
+ pendingNative.child.stdin.end();
+ if ((await pendingNative.child.exited) !== 0)
+ throw new Error("Native release failed.");
+ console.log(
+ "PASS Bun owner excludes native; killing Bun releases its PowerShell/OS handle",
+ );
+} finally {
+ for (const { child } of children) {
+ child.kill();
+ await child.exited;
+ }
+ await rm(root, { recursive: true, force: true });
+}
diff --git a/server/tests/fixtures/provider-oauth-lock-owner.ts b/server/tests/fixtures/provider-oauth-lock-owner.ts
new file mode 100644
index 00000000..f69dc8a4
--- /dev/null
+++ b/server/tests/fixtures/provider-oauth-lock-owner.ts
@@ -0,0 +1,18 @@
+import { mkdir } from "node:fs/promises";
+import { lockProviderCredentials } from "../../src/provider-oauth-lock";
+
+const file = process.argv[2];
+if (!file) throw new Error("A credential path is required.");
+if (process.argv[3] === "legacy") {
+ await mkdir(`${file}.lock`, { mode: 0o700 });
+ console.log("locked");
+ await Bun.stdin.text();
+} else {
+ const unlock = await lockProviderCredentials(file);
+ try {
+ console.log("locked");
+ await Bun.stdin.text();
+ } finally {
+ await unlock();
+ }
+}
diff --git a/server/tests/google-oauth-transport.test.ts b/server/tests/google-oauth-transport.test.ts
new file mode 100644
index 00000000..9bab0986
--- /dev/null
+++ b/server/tests/google-oauth-transport.test.ts
@@ -0,0 +1,296 @@
+import { expect, test } from "bun:test";
+import { googleRequest, googleResponse } from "../src/google-oauth-transport";
+
+test("native Gemini converts tools, screenshot input and signed tool results without losing parts", async () => {
+ const nativeParts = [
+ { text: "Looking at the page" },
+ {
+ functionCall: {
+ name: "browser",
+ args: { url: "https://example.com" },
+ id: "native-1",
+ },
+ thoughtSignature: "opaque-signature",
+ },
+ {
+ functionCall: { name: "chart", args: { values: [1, 2] }, id: "native-2" },
+ },
+ ];
+ const response = await googleResponse(
+ Response.json({
+ candidates: [{ content: { parts: nativeParts }, finishReason: "STOP" }],
+ usageMetadata: {
+ promptTokenCount: 8,
+ candidatesTokenCount: 4,
+ thoughtsTokenCount: 3,
+ totalTokenCount: 15,
+ },
+ }),
+ "gemini-3.6-flash",
+ false,
+ );
+ const completion = await response.json();
+ expect(completion.choices[0].finish_reason).toBe("tool_calls");
+ expect(completion.usage.completion_tokens).toBe(7);
+ const calls = completion.choices[0].message.tool_calls;
+ // Real generic clients keep standard fields and discard provider-specific fields.
+ const converted = googleRequest({
+ model: "gemini-3.6-flash",
+ stream: true,
+ messages: [
+ { role: "system", content: "Use the tools" },
+ {
+ role: "user",
+ content: [
+ { type: "text", text: "Read this" },
+ {
+ type: "image_url",
+ image_url: { url: "data:image/png;base64,aW1hZ2U=" },
+ },
+ ],
+ },
+ {
+ role: "assistant",
+ content: "Looking at the page",
+ tool_calls: calls.map(
+ (call: { id: string; type: string; function: unknown }) => ({
+ id: call.id,
+ type: call.type,
+ function: call.function,
+ }),
+ ),
+ },
+ { role: "tool", tool_call_id: calls[0].id, content: "Page loaded" },
+ {
+ role: "tool",
+ tool_call_id: calls[1].id,
+ content: [
+ { type: "text", text: "Rendered" },
+ {
+ type: "image_url",
+ image_url: { url: "data:image/png;base64,c2NyZWVu" },
+ },
+ ],
+ },
+ ],
+ tools: [
+ {
+ type: "function",
+ function: {
+ name: "browser",
+ description: "Browse",
+ parameters: {
+ type: "object",
+ properties: { url: { type: "string" } },
+ },
+ },
+ },
+ ],
+ tool_choice: "required",
+ });
+ expect(converted.url).toBe(
+ "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.6-flash:streamGenerateContent?alt=sse",
+ );
+ expect(converted.body).toMatchObject({
+ systemInstruction: { parts: [{ text: "Use the tools" }] },
+ toolConfig: { functionCallingConfig: { mode: "ANY" } },
+ tools: [
+ {
+ functionDeclarations: [
+ { name: "browser", parametersJsonSchema: { type: "object" } },
+ ],
+ },
+ ],
+ });
+ expect(converted.body.contents[0].parts[1]).toEqual({
+ inlineData: { mimeType: "image/png", data: "aW1hZ2U=" },
+ });
+ expect(converted.body.contents[1].parts).toEqual(nativeParts);
+ expect(converted.body.contents[2].parts).toEqual([
+ {
+ functionResponse: {
+ name: "browser",
+ id: "native-1",
+ response: { result: "Page loaded" },
+ },
+ },
+ {
+ functionResponse: {
+ name: "chart",
+ id: "native-2",
+ response: { result: "Rendered" },
+ parts: [{ inlineData: { mimeType: "image/png", data: "c2NyZWVu" } }],
+ },
+ },
+ ]);
+});
+
+test("Gemini SSE produces incremental OpenAI text, signed tool calls, usage and DONE", async () => {
+ const frames = [
+ { candidates: [{ content: { parts: [{ text: "Hello " }] } }] },
+ {
+ candidates: [
+ {
+ content: {
+ parts: [
+ { text: "world" },
+ {
+ functionCall: {
+ name: "browser",
+ args: { url: "https://example.com" },
+ },
+ thoughtSignature: "signed",
+ },
+ ],
+ },
+ finishReason: "STOP",
+ },
+ ],
+ usageMetadata: {
+ promptTokenCount: 2,
+ candidatesTokenCount: 3,
+ totalTokenCount: 5,
+ },
+ },
+ ];
+ const wire = frames
+ .map((frame) => `data: ${JSON.stringify(frame)}\r\n\r\n`)
+ .join("");
+ const bytes = new TextEncoder().encode(wire);
+ const upstream = new Response(
+ new ReadableStream({
+ start(controller) {
+ for (let offset = 0; offset < bytes.length; offset += 7)
+ controller.enqueue(bytes.slice(offset, offset + 7));
+ controller.close();
+ },
+ }),
+ { headers: { "content-type": "text/event-stream" } },
+ );
+ const response = await googleResponse(
+ upstream,
+ "gemini-3.6-flash",
+ true,
+ true,
+ );
+ const text = await response.text();
+ const chunks = text
+ .split("\n\n")
+ .filter((line) => line.startsWith("data: {"))
+ .map((line) => JSON.parse(line.slice(6)));
+ expect(
+ chunks
+ .flatMap((chunk) => chunk.choices)
+ .map((choice) => choice.delta.content ?? "")
+ .join(""),
+ ).toBe("Hello world");
+ const toolChunk = chunks.find((chunk) => chunk.choices[0]?.delta.tool_calls);
+ expect(toolChunk.choices[0].delta.tool_calls[0].function.name).toBe(
+ "browser",
+ );
+ expect(
+ chunks.some((chunk) => chunk.choices[0]?.finish_reason === "tool_calls"),
+ ).toBe(true);
+ expect(chunks.at(-1).usage.total_tokens).toBe(5);
+ expect(text.endsWith("data: [DONE]\n\n")).toBe(true);
+});
+
+test("unsupported content and unsafe model names fail before sending provider credentials", () => {
+ expect(() => googleRequest({ model: "../../other", messages: [] })).toThrow();
+ expect(() =>
+ googleRequest({
+ model: "gemini-3.6-flash",
+ messages: [
+ { role: "user", content: [{ type: "audio", data: "unsupported" }] },
+ ],
+ }),
+ ).toThrow();
+});
+
+const terminalFrame = 'data: {"candidates":[{"finishReason":"STOP"}]}\n\n';
+const partialFrame =
+ 'data: {"candidates":[{"content":{"parts":[{"text":"partial"}]}}]}\n\n';
+const providerErrorFrame =
+ 'data: {"error":{"code":429,"message":"private provider detail"}}\n\n';
+const sanitizedError = `data: ${JSON.stringify({
+ error: {
+ message: "The Google model stream failed or ended early. Try again.",
+ type: "provider_error",
+ code: "incomplete_model_stream",
+ },
+})}`;
+
+async function expectFailedStream(chunks: string[]) {
+ const encoder = new TextEncoder();
+ const upstream = new Response(
+ new ReadableStream<Uint8Array>({
+ start(controller) {
+ for (const chunk of chunks) controller.enqueue(encoder.encode(chunk));
+ controller.close();
+ },
+ }),
+ { headers: { "content-type": "text/event-stream" } },
+ );
+ const response = await googleResponse(upstream, "gemini-3.6-flash", true);
+ const text = await response.text();
+ const events = text.split("\n\n").filter(Boolean);
+ expect(events.filter((event) => event.startsWith('data: {"error":'))).toEqual(
+ [sanitizedError],
+ );
+ expect(events.at(-1)).toBe(sanitizedError);
+ expect(text).not.toContain("private provider detail");
+ expect(text).not.toContain("content after failure");
+ expect(text).not.toMatch(/"finish_reason"\s*:\s*"/);
+ expect(text).not.toContain("[DONE]");
+ return text;
+}
+
+// A terminal reason is already present, so the missing-terminal guard cannot
+// mask a missing parser, framing, or trailing-data guard in these cases.
+test.each([
+ ["provider error", providerErrorFrame],
+ ["malformed JSON", 'data: {"private provider detail":\n\n'],
+ ["invalid schema", 'data: {"candidates":"private provider detail"}\n\n'],
+ ["invalid SSE line", "private provider detail\n\n"],
+ ["trailing fragment", "private provider detail"],
+ [
+ "undelimited data",
+ 'data: {"candidates":[{"content":{"parts":[{"text":"private provider detail"}]}}]}\n',
+ ],
+])(
+ "native stream rejects %s after a terminal frame",
+ async (_name, invalid) => {
+ await expectFailedStream([terminalFrame + invalid]);
+ },
+);
+
+test("native stream rejects a partial response without a terminal reason", async () => {
+ const text = await expectFailedStream([partialFrame]);
+ expect(text).toContain('"content":"partial"');
+});
+
+const laterDataLine =
+ 'data: {"candidates":[{"content":{"parts":[{"text":"content after failure"}]},"finishReason":"STOP"}]}\n';
+test.each([
+ [
+ "the same chunk",
+ [`${partialFrame}${providerErrorFrame}${laterDataLine}\n`],
+ ],
+ [
+ "separate chunks",
+ [partialFrame + providerErrorFrame, `${laterDataLine}\n`],
+ ],
+ [
+ "a later chunk completing an interrupted event",
+ [
+ `${partialFrame}${laterDataLine}private provider detail\n`,
+ `\n${terminalFrame}`,
+ ],
+ ],
+] satisfies [string, string[]][])(
+ "native stream cannot resume after failure in %s",
+ async (_name, chunks) => {
+ const text = await expectFailedStream(chunks);
+ expect(text).toContain('"content":"partial"');
+ },
+);
diff --git a/server/tests/provider-oauth.test.ts b/server/tests/provider-oauth.test.ts
new file mode 100644
index 00000000..023c96b3
--- /dev/null
+++ b/server/tests/provider-oauth.test.ts
@@ -0,0 +1,624 @@
+import { afterEach, expect, spyOn, test } from "bun:test";
+import * as fsPromises from "node:fs/promises";
+import {
+ chmod,
+ mkdir,
+ mkdtemp,
+ readFile,
+ rm,
+ stat,
+ symlink,
+ writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Hono } from "hono";
+import { fileURLToPath } from "node:url";
+import { lockProviderCredentials } from "../src/provider-oauth-lock";
+import {
+ clearDesktopConnectionFailure,
+ mountDesktopConnectionFailure,
+} from "../src/desktop-connection-failure";
+import {
+ createProviderOAuthProxy,
+ type ModelOAuthRecord,
+ mountProviderOAuthProxy,
+} from "../src/provider-oauth";
+
+const cleanup: (() => Promise<void> | void)[] = [];
+afterEach(async () => {
+ try {
+ for (const dispose of cleanup.splice(0).reverse()) await dispose();
+ } finally {
+ clearDesktopConnectionFailure("model");
+ }
+});
+
+function record(overrides: Partial<ModelOAuthRecord> = {}): ModelOAuthRecord {
+ return {
+ version: 1,
+ sessionId: "session-one",
+ provider: "google",
+ clientId: "desktop-client",
+ clientSecret: "desktop-client-secret",
+ accessToken: "provider-access-token",
+ refreshToken: "provider-refresh-token",
+ expiresAt: Date.now() + 3_600_000,
+ scope: "model-scope",
+ quotaProject: "google-quota-project",
+ proxyToken: "local-proxy-token",
+ ...overrides,
+ };
+}
+
+async function fixture(
+ current: ModelOAuthRecord,
+ handler: (request: Request) => Response | Promise<Response>,
+) {
+ const root = await mkdtemp(join(tmpdir(), "openbot-model-oauth-"));
+ cleanup.push(() => rm(root, { recursive: true, force: true }));
+ const file = join(root, "model-oauth.json");
+ await writeFile(file, JSON.stringify(current), { mode: 0o600 });
+ const server = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: handler });
+ cleanup.push(() => server.stop(true));
+ const destinations: string[] = [];
+ const app = new Hono();
+ mountProviderOAuthProxy(
+ app,
+ createProviderOAuthProxy(file, {
+ fetch: async (input, init) => {
+ const url = new URL(input instanceof Request ? input.url : input);
+ destinations.push(url.href);
+ return fetch(new URL(url.pathname, server.url), init);
+ },
+ }),
+ );
+ mountDesktopConnectionFailure(app, "test-host-token");
+ const ask = (token: string | null = current.proxyToken) =>
+ app.request("/api/model-provider/v1/chat/completions", {
+ method: "POST",
+ headers: {
+ "content-type": "application/json",
+ cookie: "browser-session-must-not-pass-upstream",
+ ...(token === null ? {} : { authorization: `Bearer ${token}` }),
+ },
+ body: JSON.stringify({
+ model: "chosen-model",
+ messages: [],
+ stream: true,
+ }),
+ });
+ return { app, file, ask, destinations, providerUrl: server.url };
+}
+
+test("the model proxy requires its bearer even with a browser cookie", async () => {
+ const f = await fixture(record(), () => new Response("not called"));
+ for (const token of [null, "wrong-token"]) {
+ const response = await f.ask(token);
+ expect(response.status).toBe(401);
+ expect(await response.text()).not.toContain("provider-access-token");
+ }
+ expect(f.destinations).toEqual([]);
+});
+
+test("Google uses provider bearer and quota project while preserving streamed model output", async () => {
+ const f = await fixture(record(), async (request) => {
+ expect(request.headers.get("authorization")).toBe(
+ "Bearer provider-access-token",
+ );
+ expect(request.headers.get("x-goog-user-project")).toBe(
+ "google-quota-project",
+ );
+ expect(request.headers.get("cookie")).toBeNull();
+ expect(await request.json()).toMatchObject({
+ contents: [],
+ });
+ return new Response(
+ 'data: {"candidates":[{"content":{"parts":[{"text":"Hello"}]},"finishReason":"STOP"}]}\n\n',
+ {
+ headers: {
+ "content-type": "text/event-stream",
+ "set-cookie": "must-not-leave-provider",
+ },
+ },
+ );
+ });
+ const response = await f.ask();
+ expect(response.status).toBe(200);
+ expect(response.headers.get("content-type")).toBe("text/event-stream");
+ expect(response.headers.get("set-cookie")).toBeNull();
+ expect(response.headers.get("cache-control")).toBe("no-store");
+ expect(await response.text()).toContain("data: [DONE]");
+ expect(f.destinations).toEqual([
+ "https://generativelanguage.googleapis.com/v1beta/models/chosen-model:streamGenerateContent?alt=sse",
+ ]);
+});
+
+test("xAI uses the existing compatible model endpoint without Google quota headers", async () => {
+ const f = await fixture(
+ record({ provider: "xai", quotaProject: undefined }),
+ (request) => {
+ expect(request.headers.get("authorization")).toBe(
+ "Bearer provider-access-token",
+ );
+ expect(request.headers.get("x-goog-user-project")).toBeNull();
+ return Response.json({ choices: [] });
+ },
+ );
+ expect((await f.ask()).status).toBe(200);
+ expect(f.destinations).toEqual(["https://api.x.ai/v1/chat/completions"]);
+});
+
+test("concurrent requests refresh once and persist the rotated pair before forwarding", async () => {
+ let refreshes = 0;
+ const f = await fixture(record({ expiresAt: 1 }), async (request) => {
+ if (new URL(request.url).pathname === "/token") {
+ refreshes++;
+ const body = new URLSearchParams(await request.text());
+ expect(body.get("grant_type")).toBe("refresh_token");
+ expect(body.get("refresh_token")).toBe("provider-refresh-token");
+ expect(body.get("client_id")).toBe("desktop-client");
+ expect(body.get("client_secret")).toBe("desktop-client-secret");
+ await Bun.sleep(20);
+ return Response.json({
+ access_token: "rotated-access",
+ refresh_token: "rotated-refresh",
+ expires_in: 3600,
+ });
+ }
+ expect(request.headers.get("authorization")).toBe("Bearer rotated-access");
+ const saved = JSON.parse(await readFile(f.file, "utf8"));
+ expect(saved.refreshToken).toBe("rotated-refresh");
+ return new Response(
+ 'data: {"candidates":[{"content":{"parts":[{"text":"Refreshed"}]},"finishReason":"STOP"}]}\n\n',
+ { headers: { "content-type": "text/event-stream" } },
+ );
+ });
+ const responses = await Promise.all(Array.from({ length: 8 }, () => f.ask()));
+ expect(responses.map((response) => response.status)).toEqual(
+ Array(8).fill(200),
+ );
+ for (const response of responses)
+ expect(await response.text()).toContain("data: [DONE]");
+ expect(refreshes).toBe(1);
+ const saved = JSON.parse(await readFile(f.file, "utf8"));
+ expect(saved).toMatchObject({
+ accessToken: "rotated-access",
+ refreshToken: "rotated-refresh",
+ sessionId: "session-one",
+ });
+ expect(saved.expiresAt).toBeGreaterThan(Date.now());
+ if (process.platform !== "win32")
+ expect((await stat(f.file)).mode & 0o777).toBe(0o600);
+ expect((await f.ask()).status).toBe(200);
+ expect(refreshes).toBe(1);
+});
+
+test("invalid Google requests are rejected before forwarding the provider bearer", async () => {
+ const f = await fixture(record(), () => new Response("must not be called"));
+ const response = await f.app.request(
+ "/api/model-provider/v1/chat/completions",
+ {
+ method: "POST",
+ headers: {
+ authorization: "Bearer local-proxy-token",
+ "content-type": "application/json",
+ },
+ body: JSON.stringify({ model: "../outside", messages: [] }),
+ },
+ );
+ expect(response.status).toBe(400);
+ expect(f.destinations).toEqual([]);
+});
+
+test("an unexpired rejected xAI token is refreshed once and the request is replayed", async () => {
+ let refreshes = 0;
+ let calls = 0;
+ const f = await fixture(
+ record({
+ provider: "xai",
+ quotaProject: undefined,
+ clientSecret: undefined,
+ }),
+ async (request) => {
+ if (new URL(request.url).pathname === "/oauth2/token") {
+ refreshes++;
+ const body = new URLSearchParams(await request.text());
+ expect(body.get("client_secret")).toBeNull();
+ return Response.json({
+ access_token: "new-xai-token",
+ expires_in: 3600,
+ });
+ }
+ calls++;
+ return request.headers.get("authorization") === "Bearer new-xai-token"
+ ? Response.json({ choices: [] })
+ : Response.json({ error: "expired" }, { status: 401 });
+ },
+ );
+ expect((await f.ask()).status).toBe(200);
+ expect(refreshes).toBe(1);
+ expect(calls).toBe(2);
+ expect(JSON.parse(await readFile(f.file, "utf8")).refreshToken).toBe(
+ "provider-refresh-token",
+ );
+});
+
+test("a refused refresh exposes no provider response or credential and keeps the old file", async () => {
+ const initial = record({ expiresAt: 1 });
+ const f = await fixture(initial, () =>
+ Response.json(
+ { error: "invalid_grant", secret: initial.refreshToken },
+ { status: 400 },
+ ),
+ );
+ const response = await f.ask();
+ expect(response.status).toBe(401);
+ const body = await response.text();
+ expect(body).not.toContain(initial.refreshToken);
+ expect(body).not.toContain("invalid_grant");
+ expect(JSON.parse(await readFile(f.file, "utf8"))).toEqual(initial);
+});
+
+test.each(["model", "refresh"] as const)(
+ "%s endpoint redirects cannot carry provider credentials elsewhere",
+ async (endpoint) => {
+ let leaked = 0;
+ const destination = Bun.serve({
+ hostname: "127.0.0.1",
+ port: 0,
+ fetch: () => {
+ leaked++;
+ return new Response("leaked");
+ },
+ });
+ cleanup.push(() => destination.stop(true));
+ const f = await fixture(
+ record({
+ expiresAt: endpoint === "refresh" ? 1 : Date.now() + 3_600_000,
+ }),
+ () => Response.redirect(destination.url, 307),
+ );
+ const response = await f.ask();
+ expect(response.status).toBe(endpoint === "refresh" ? 401 : 502);
+ expect(response.headers.get("location")).toBeNull();
+ expect(leaked).toBe(0);
+ },
+);
+
+test("a completed new sign-in cannot be overwritten by an older in-flight refresh", async () => {
+ let began!: () => void;
+ let finish!: () => void;
+ const started = new Promise<void>((resolve) => {
+ began = resolve;
+ });
+ const release = new Promise<void>((resolve) => {
+ finish = resolve;
+ });
+ const f = await fixture(record({ expiresAt: 1 }), async () => {
+ began();
+ await release;
+ return Response.json({
+ access_token: "old-session-rotated-access",
+ refresh_token: "old-session-rotated-refresh",
+ expires_in: 3600,
+ });
+ });
+ const pending = f.ask();
+ await started;
+ const replacement = record({
+ sessionId: "new-sign-in",
+ proxyToken: "new-local-token",
+ refreshToken: "new-sign-in-refresh",
+ });
+ await writeFile(f.file, JSON.stringify(replacement), { mode: 0o600 });
+ finish();
+ expect((await pending).status).toBe(401);
+ expect(JSON.parse(await readFile(f.file, "utf8"))).toEqual(replacement);
+});
+
+test("missing or malformed credential files fail closed without exposing their content", async () => {
+ const f = await fixture(record(), () => new Response("not called"));
+ await writeFile(f.file, '{"accessToken":"malformed-private-token"');
+ let response = await f.ask();
+ expect(response.status).toBe(503);
+ expect(await response.text()).not.toContain("malformed-private-token");
+ await rm(f.file);
+ response = await f.ask();
+ expect(response.status).toBe(503);
+ expect(f.destinations).toEqual([]);
+});
+
+async function authenticationFailure(app: Hono) {
+ const response = await app.request("/api/desktop/connection-failure", {
+ headers: { "x-openbot-desktop-host-token": "test-host-token" },
+ });
+ return response.json();
+}
+
+test("an abandoned legacy lock directory does not consume and lose a rotated token", async () => {
+ let exchanges = 0;
+ const f = await fixture(record({ provider: "xai", expiresAt: 1 }), () => {
+ exchanges++;
+ return Response.json({
+ access_token: "next",
+ refresh_token: "next-refresh",
+ expires_in: 3600,
+ });
+ });
+ const child = await lockOwner(f.file, "legacy");
+ // The former Rust create_dir used the process umask (commonly 0755).
+ if (process.platform !== "win32") await chmod(`${f.file}.lock`, 0o755);
+ child.kill("SIGKILL");
+ await child.exited;
+ const response = await f.ask();
+ expect(response.status).toBe(200);
+ expect(exchanges).toBe(2); // One refresh and one model request.
+ expect(JSON.parse(await readFile(f.file, "utf8")).refreshToken).toBe(
+ "next-refresh",
+ );
+}, 10000);
+
+test("independent proxy instances serialize real rotating-token exchanges", async () => {
+ let exchanges = 0;
+ const initial = record({ provider: "xai", expiresAt: 1 });
+ const f = await fixture(initial, async (request) => {
+ if (new URL(request.url).pathname === "/oauth2/token") {
+ const exchange = ++exchanges;
+ await Bun.sleep(50);
+ return exchange === 1
+ ? Response.json({
+ access_token: "next",
+ refresh_token: "next-refresh",
+ expires_in: 3600,
+ })
+ : Response.json({ error: "already spent" }, { status: 400 });
+ }
+ return Response.json({ choices: [] });
+ });
+ // Each separate Hono/proxy instance has its own in-memory refresh deduplication map.
+ const other = createProviderOAuthProxy(f.file, {
+ fetch: async (input, init) => {
+ const url = new URL(input instanceof Request ? input.url : input);
+ return fetch(new URL(url.pathname, f.providerUrl), init);
+ },
+ });
+ const responses = await Promise.all([
+ f.ask(),
+ other(
+ new Request("http://localhost/model", {
+ method: "POST",
+ headers: { authorization: `Bearer ${initial.proxyToken}` },
+ body: JSON.stringify({ model: "model", messages: [] }),
+ }),
+ ),
+ ]);
+ expect(responses.map((response) => response.status)).toEqual([200, 200]);
+ expect(exchanges).toBe(1);
+});
+
+test("an unreadable request body does not invalidate provider sign-in", async () => {
+ const f = await fixture(record(), () => new Response("must not be called"));
+ const response = await f.app.request(
+ "/api/model-provider/v1/chat/completions",
+ {
+ method: "POST",
+ headers: { authorization: "Bearer local-proxy-token" },
+ body: new ReadableStream({
+ start(controller) {
+ controller.error(new Error("client disconnected"));
+ },
+ }),
+ },
+ );
+ expect(response.status).toBe(400);
+ expect(f.destinations).toEqual([]);
+ expect(await authenticationFailure(f.app)).toBeNull();
+});
+
+test("a quota-project permission denial stays 403 without invalidating sign-in", async () => {
+ const f = await fixture(record(), () =>
+ Response.json({ error: "private quota project detail" }, { status: 403 }),
+ );
+ const response = await f.ask();
+ expect(response.status).toBe(403);
+ expect(await response.text()).not.toContain("private quota project detail");
+ expect(await authenticationFailure(f.app)).toBeNull();
+ expect(f.destinations).toHaveLength(1);
+});
+
+test("credential file paths must be absolute", () => {
+ expect(() => createProviderOAuthProxy("relative.json")).toThrow("absolute");
+});
+
+test.each(["world-readable", "symlink", "oversized", "missing-quota"] as const)(
+ "%s credential files are refused before provider I/O",
+ async (kind) => {
+ if (kind === "world-readable" && process.platform === "win32") return;
+ const f = await fixture(record(), () => new Response("must not be called"));
+ if (kind === "world-readable") await chmod(f.file, 0o644);
+ if (kind === "symlink") {
+ const target = `${f.file}.target`;
+ await writeFile(target, JSON.stringify(record()), { mode: 0o600 });
+ await rm(f.file);
+ await symlink(target, f.file);
+ }
+ if (kind === "oversized")
+ await writeFile(
+ f.file,
+ JSON.stringify(record({ scope: "x".repeat(64 * 1024) })),
+ );
+ if (kind === "missing-quota")
+ await writeFile(
+ f.file,
+ JSON.stringify(record({ quotaProject: undefined })),
+ );
+ const response = await f.ask();
+ expect(response.status).toBe(503);
+ expect(f.destinations).toEqual([]);
+ expect(await response.text()).not.toContain("provider-refresh-token");
+ },
+);
+
+async function lockOwner(file: string, mode?: "legacy") {
+ const child = Bun.spawn(
+ [
+ process.execPath,
+ fileURLToPath(
+ new URL("./fixtures/provider-oauth-lock-owner.ts", import.meta.url),
+ ),
+ file,
+ ...(mode ? [mode] : []),
+ ],
+ {
+ stdin: "pipe",
+ stdout: "pipe",
+ stderr: "pipe",
+ },
+ );
+ cleanup.push(async () => {
+ child.kill();
+ await child.exited;
+ });
+ const reader = child.stdout.getReader();
+ const timeout = setTimeout(() => child.kill(), 15000);
+ try {
+ let message = "";
+ while (!message.includes("\n")) {
+ const { value, done } = await reader.read();
+ if (done)
+ throw new Error(
+ `Lock owner exited: ${await new Response(child.stderr).text()}`,
+ );
+ message += new TextDecoder().decode(value);
+ }
+ expect(message.trim()).toBe("locked");
+ } finally {
+ clearTimeout(timeout);
+ reader.releaseLock();
+ }
+ return child;
+}
+
+test("killing a real lock owner permits a subsequent durable rotating-token exchange", async () => {
+ let refreshes = 0;
+ const f = await fixture(
+ record({ provider: "xai", expiresAt: 1 }),
+ (request) => {
+ if (new URL(request.url).pathname === "/oauth2/token") {
+ refreshes++;
+ return Response.json({
+ access_token: "recovered",
+ refresh_token: "recovered-refresh",
+ expires_in: 3600,
+ });
+ }
+ return Response.json({ choices: [] });
+ },
+ );
+ const child = await lockOwner(f.file);
+ child.kill("SIGKILL");
+ await child.exited;
+ expect((await f.ask()).status).toBe(200);
+ expect(refreshes).toBe(1);
+ expect(JSON.parse(await readFile(f.file, "utf8")).refreshToken).toBe(
+ "recovered-refresh",
+ );
+}, 20000);
+
+test("a live lock owner prevents any provider exchange until ownership is obtained", async () => {
+ let refreshes = 0;
+ const f = await fixture(
+ record({ provider: "xai", expiresAt: 1 }),
+ (request) => {
+ if (new URL(request.url).pathname === "/oauth2/token") {
+ refreshes++;
+ return Response.json({
+ access_token: "next",
+ refresh_token: "next-refresh",
+ expires_in: 3600,
+ });
+ }
+ return Response.json({ choices: [] });
+ },
+ );
+ const child = await lockOwner(f.file);
+ const pending = f.ask();
+ await Bun.sleep(100);
+ expect(refreshes).toBe(0);
+ child.stdin.end();
+ expect(await child.exited).toBe(0);
+ expect((await pending).status).toBe(200);
+ expect(refreshes).toBe(1);
+}, 20000);
+
+test("a lock timeout returns a retryable failure without consuming a refresh token or recording an auth failure", async () => {
+ const f = await fixture(
+ record({ expiresAt: 1 }),
+ () => new Response("must not be called"),
+ );
+ const unlock = await lockProviderCredentials(f.file);
+ try {
+ expect((await f.ask()).status).toBe(503);
+ expect(f.destinations).toEqual([]);
+ expect(await authenticationFailure(f.app)).toBeNull();
+ expect(JSON.parse(await readFile(f.file, "utf8")).refreshToken).toBe(
+ "provider-refresh-token",
+ );
+ } finally {
+ await unlock();
+ }
+}, 20000);
+
+test("a redirected lock inode is rejected before a provider exchange", async () => {
+ const f = await fixture(
+ record({ expiresAt: 1 }),
+ () => new Response("must not be called"),
+ );
+ await mkdir(`${f.file}.lock`, { mode: 0o700 });
+ const target = `${f.file}.untouched`;
+ await writeFile(target, "untouched", { mode: 0o600 });
+ await symlink(target, join(`${f.file}.lock`, "owner.lock"));
+ expect((await f.ask()).status).toBe(503);
+ expect(f.destinations).toEqual([]);
+ expect(await readFile(target, "utf8")).toBe("untouched");
+});
+
+test("Windows validates the opened credential identity before reading a replaced path", async () => {
+ const f = await fixture(record({ provider: "xai" }), () =>
+ Response.json({ choices: [] }),
+ );
+ const originalPlatform = Object.getOwnPropertyDescriptor(
+ process,
+ "platform",
+ )!;
+ const before = await fsPromises.lstat(f.file, { bigint: true });
+ const replacement = `${f.file}.replacement`;
+ await writeFile(
+ replacement,
+ JSON.stringify(
+ record({ provider: "xai", accessToken: "must-not-be-forwarded" }),
+ ),
+ { mode: 0o600 },
+ );
+ // Return the real metadata sampled before another writer atomically replaced
+ // the path: a deterministic race between Windows lstat and open.
+ Object.defineProperty(process, "platform", {
+ value: "win32",
+ configurable: true,
+ });
+ try {
+ expect((await f.ask()).status).toBe(200); // Valid file identities still work.
+ f.destinations.length = 0;
+ await fsPromises.rename(replacement, f.file);
+ const inspect = spyOn(fsPromises, "lstat").mockResolvedValue(before);
+ try {
+ expect((await f.ask()).status).toBe(503);
+ expect(f.destinations).toEqual([]);
+ } finally {
+ inspect.mockRestore();
+ }
+ } finally {
+ Object.defineProperty(process, "platform", originalPlatform);
+ }
+});