mirror of
https://github.com/openai/codex.git
synced 2026-11-16 22:00:36 +00:00
Add experimental ChatGPT workspace switching to app-server (#57514)
## What changed - Add `accountSession/list` and `accountSession/switch` for the active managed ChatGPT login, with optional workspace membership refresh. - Validate membership and workspace policy, pause new turns, and unload running threads before switching credentials. Notify clients with `thread/closed` and `account/updated`; selecting the current workspace leaves threads running. - Support browser sign-in for SSO through `allowBrowserLogin`, binding the callback to the requesting login and workspace. Require a separate sign-in for government workspaces. - Preserve the selected workspace across token refresh and conditionally restore the previous workspace if routing validation fails. Guard credential writes against concurrent login or logout changes. ## Testing Add app-server and auth tests covering workspace switching, credential preservation, policy and identity rejection, conditional rollback, stale sessions, and SSO callback validation. GitOrigin-RevId: 1234abc33b71e69b66318da3e201fccc08867906
This commit is contained in:
committed by
copyberry
parent
27ace641fe
commit
d257beb16a
+97
@@ -6919,6 +6919,103 @@
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"AccountSession": {
|
||||
"properties": {
|
||||
"displayName": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"email": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"imageUrl": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"isActive": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"lastUsedAt": {
|
||||
"format": "int64",
|
||||
"type": "integer"
|
||||
},
|
||||
"selectedWorkspaceAccountId": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"sessionId": {
|
||||
"type": "string"
|
||||
},
|
||||
"userId": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"workspaces": {
|
||||
"items": {
|
||||
"$ref": "#/definitions/v2/AccountSessionWorkspace"
|
||||
},
|
||||
"type": "array"
|
||||
}
|
||||
},
|
||||
"required": [
|
||||
"isActive",
|
||||
"lastUsedAt",
|
||||
"sessionId",
|
||||
"workspaces"
|
||||
],
|
||||
"type": "object"
|
||||
},
|
||||
"AccountSessionWorkspace": {
|
||||
"properties": {
|
||||
"accountId": {
|
||||
"type": "string"
|
||||
},
|
||||
"imageUrl": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"kind": {
|
||||
"anyOf": [
|
||||
{
|
||||
"$ref": "#/definitions/v2/AccountSessionWorkspaceKind"
|
||||
},
|
||||
{
|
||||
"type": "null"
|
||||
}
|
||||
]
|
||||
},
|
||||
"name": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
}
|
||||
},
|
||||
"required": [
|
||||
"accountId"
|
||||
],
|
||||
"type": "object"
|
||||
},
|
||||
"AccountSessionWorkspaceKind": {
|
||||
"enum": [
|
||||
"personal",
|
||||
"workspace"
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"AccountTokenUsageDailyBucket": {
|
||||
"properties": {
|
||||
"startDate": {
|
||||
|
||||
+97
@@ -154,6 +154,103 @@
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"AccountSession": {
|
||||
"properties": {
|
||||
"displayName": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"email": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"imageUrl": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"isActive": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"lastUsedAt": {
|
||||
"format": "int64",
|
||||
"type": "integer"
|
||||
},
|
||||
"selectedWorkspaceAccountId": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"sessionId": {
|
||||
"type": "string"
|
||||
},
|
||||
"userId": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"workspaces": {
|
||||
"items": {
|
||||
"$ref": "#/definitions/AccountSessionWorkspace"
|
||||
},
|
||||
"type": "array"
|
||||
}
|
||||
},
|
||||
"required": [
|
||||
"isActive",
|
||||
"lastUsedAt",
|
||||
"sessionId",
|
||||
"workspaces"
|
||||
],
|
||||
"type": "object"
|
||||
},
|
||||
"AccountSessionWorkspace": {
|
||||
"properties": {
|
||||
"accountId": {
|
||||
"type": "string"
|
||||
},
|
||||
"imageUrl": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
},
|
||||
"kind": {
|
||||
"anyOf": [
|
||||
{
|
||||
"$ref": "#/definitions/AccountSessionWorkspaceKind"
|
||||
},
|
||||
{
|
||||
"type": "null"
|
||||
}
|
||||
]
|
||||
},
|
||||
"name": {
|
||||
"type": [
|
||||
"string",
|
||||
"null"
|
||||
]
|
||||
}
|
||||
},
|
||||
"required": [
|
||||
"accountId"
|
||||
],
|
||||
"type": "object"
|
||||
},
|
||||
"AccountSessionWorkspaceKind": {
|
||||
"enum": [
|
||||
"personal",
|
||||
"workspace"
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"AccountTokenUsageDailyBucket": {
|
||||
"properties": {
|
||||
"startDate": {
|
||||
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -0,0 +1,6 @@
|
||||
// GENERATED CODE! DO NOT MODIFY BY HAND!
|
||||
|
||||
// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
|
||||
import type { AccountSessionWorkspace } from "./AccountSessionWorkspace";
|
||||
|
||||
export type AccountSession = { sessionId: string, email: string | null, userId: string | null, displayName: string | null, imageUrl: string | null, lastUsedAt: bigint, isActive: boolean, selectedWorkspaceAccountId: string | null, workspaces: Array<AccountSessionWorkspace>, };
|
||||
@@ -0,0 +1,6 @@
|
||||
// GENERATED CODE! DO NOT MODIFY BY HAND!
|
||||
|
||||
// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
|
||||
import type { AccountSessionWorkspaceKind } from "./AccountSessionWorkspaceKind";
|
||||
|
||||
export type AccountSessionWorkspace = { accountId: string, name: string | null, imageUrl: string | null, kind: AccountSessionWorkspaceKind | null, };
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
// GENERATED CODE! DO NOT MODIFY BY HAND!
|
||||
|
||||
// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
|
||||
|
||||
export type AccountSessionWorkspaceKind = "personal" | "workspace";
|
||||
@@ -4,6 +4,9 @@ export type { Account } from "./Account";
|
||||
export type { AccountLoginCompletedNotification } from "./AccountLoginCompletedNotification";
|
||||
export type { AccountRateLimitsUpdatedNotification } from "./AccountRateLimitsUpdatedNotification";
|
||||
export type { AccountRoutingOverride } from "./AccountRoutingOverride";
|
||||
export type { AccountSession } from "./AccountSession";
|
||||
export type { AccountSessionWorkspace } from "./AccountSessionWorkspace";
|
||||
export type { AccountSessionWorkspaceKind } from "./AccountSessionWorkspaceKind";
|
||||
export type { AccountTokenUsageDailyBucket } from "./AccountTokenUsageDailyBucket";
|
||||
export type { AccountTokenUsageSummary } from "./AccountTokenUsageSummary";
|
||||
export type { AccountUpdatedNotification } from "./AccountUpdatedNotification";
|
||||
|
||||
@@ -1358,6 +1358,22 @@ client_request_definitions! {
|
||||
response: v2::CancelLoginAccountResponse,
|
||||
},
|
||||
|
||||
#[experimental("accountSession/list")]
|
||||
AccountSessionsList => "accountSession/list" {
|
||||
params: v2::AccountSessionsListParams,
|
||||
serialization: global("account-auth"),
|
||||
manual_payload_conversion: manual,
|
||||
response: v2::AccountSessionsResponse,
|
||||
},
|
||||
|
||||
#[experimental("accountSession/switch")]
|
||||
AccountSessionsSwitch => "accountSession/switch" {
|
||||
params: v2::AccountSessionsSwitchParams,
|
||||
serialization: global("account-auth"),
|
||||
manual_payload_conversion: manual,
|
||||
response: v2::AccountSessionsSwitchResponse,
|
||||
},
|
||||
|
||||
LogoutAccount => "account/logout" {
|
||||
params: #[ts(type = "undefined")] #[serde(skip_serializing_if = "Option::is_none")] Option<()>,
|
||||
serialization: global("account-auth"),
|
||||
|
||||
@@ -227,8 +227,26 @@ pub struct AccountSessionsLogoutParams {
|
||||
#[serde(rename_all = "camelCase")]
|
||||
#[ts(export_to = "v2/")]
|
||||
pub struct AccountSessionsSwitchParams {
|
||||
/// Opaque active-login identifier returned by accountSession/list.
|
||||
pub session_id: String,
|
||||
/// Workspace to select within that login; this is not a user identifier.
|
||||
pub account_id: String,
|
||||
/// Allow Core to start browser sign-in if this session needs SSO for the workspace.
|
||||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||||
#[ts(optional, as = "Option<bool>")]
|
||||
pub allow_browser_login: bool,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)]
|
||||
#[serde(untagged, rename_all_fields = "camelCase")]
|
||||
#[ts(untagged, rename_all_fields = "camelCase", export_to = "v2/")]
|
||||
pub enum AccountSessionsSwitchResponse {
|
||||
Switched {
|
||||
#[serde(flatten)]
|
||||
sessions: AccountSessionsResponse,
|
||||
},
|
||||
/// Open the URL and await account/login/completed for this login ID.
|
||||
BrowserLogin { login_id: String, auth_url: String },
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)]
|
||||
|
||||
@@ -647,6 +647,29 @@ Omitted or null cursors preserve normal first-page behavior. Continue anchored
|
||||
pages with the returned opaque string `nextCursor`; response fields and
|
||||
`backwardsCursor` semantics are unchanged.
|
||||
|
||||
## Workspace switching (experimental)
|
||||
|
||||
For a managed ChatGPT login, `accountSession/list` returns an opaque
|
||||
`sessionId` for that login and its selected workspace. Set
|
||||
`refreshWorkspaceMetadata` to fetch the user's memberships.
|
||||
|
||||
Call `accountSession/switch` with that `sessionId` and the target workspace's
|
||||
`accountId`. Core checks the membership, stops loaded threads, exchanges the
|
||||
session token and validates the new workspace's routing. Clients receive
|
||||
`thread/closed` for unloaded threads and `account/updated` after a successful
|
||||
switch. Selecting the current workspace leaves its threads running.
|
||||
|
||||
The server remembers the selected workspace on refresh. If routing validation
|
||||
fails, Core attempts to restore the previous workspace while the same credentials
|
||||
are still current.
|
||||
|
||||
Clients that can open a browser may pass `allowBrowserLogin: true`. If the
|
||||
workspace requires SSO, the response contains `loginId` and `authUrl`. Open
|
||||
that URL and wait for `account/login/completed`. The browser can reuse an
|
||||
existing SSO session. Core accepts the callback only for the requesting login
|
||||
and target workspace. Cancel through `account/login/cancel` to keep the current
|
||||
workspace. Government workspaces require a separate sign-in.
|
||||
|
||||
# GCP provider account
|
||||
|
||||
The experimental `account/gcp/setup` method configures the built-in Vertex AI provider.
|
||||
|
||||
@@ -1842,6 +1842,16 @@ impl MessageProcessor {
|
||||
.await
|
||||
.map(|response| Some(response.into()))
|
||||
}
|
||||
ClientRequest::AccountSessionsList { params, .. } => self
|
||||
.account_processor
|
||||
.list_account_sessions(params)
|
||||
.await
|
||||
.map(|response| Some(ClientResponsePayload::AccountSessionsList(response))),
|
||||
ClientRequest::AccountSessionsSwitch { params, .. } => self
|
||||
.account_processor
|
||||
.switch_account_session(params, &self.thread_processor, &self.turn_admission)
|
||||
.await
|
||||
.map(|response| Some(ClientResponsePayload::AccountSessionsSwitch(response))),
|
||||
ClientRequest::LogoutAccount { .. } => {
|
||||
self.account_processor
|
||||
.logout_account(request_id.clone())
|
||||
|
||||
@@ -24,6 +24,7 @@ mod gateway_oauth;
|
||||
mod gcp_setup;
|
||||
mod rate_limit_resets;
|
||||
mod workspace_routing;
|
||||
mod workspace_switching;
|
||||
|
||||
pub(super) use enterprise_login::EnterpriseLoginCompletion;
|
||||
pub(super) use enterprise_login::EnterpriseLoginTarget;
|
||||
@@ -690,6 +691,15 @@ impl AccountRequestProcessor {
|
||||
let opts = self
|
||||
.login_chatgpt_common(codex_streamlined_login, login_success_page)
|
||||
.await?;
|
||||
let (login_id, auth_url) = self.start_browser_login(opts, /*pause*/ None).await?;
|
||||
Ok(LoginAccountResponse::Chatgpt { login_id, auth_url })
|
||||
}
|
||||
|
||||
async fn start_browser_login(
|
||||
&self,
|
||||
opts: LoginServerOptions,
|
||||
pause: Option<crate::turn_admission::TurnAdmissionPause>,
|
||||
) -> Result<(String, String), JSONRPCErrorError> {
|
||||
let server = run_login_server(opts)
|
||||
.map_err(|err| internal_error(format!("failed to start login server: {err}")))?;
|
||||
let login_id = Uuid::new_v4();
|
||||
@@ -711,6 +721,8 @@ impl AccountRequestProcessor {
|
||||
let active_login = self.active_login.clone();
|
||||
let auth_url = server.auth_url.clone();
|
||||
let task = async move {
|
||||
// Workspace credentials may change in the callback. Resume turns after caches and clients are updated.
|
||||
let _pause = pause;
|
||||
let (success, error_msg, onboarding_entrypoint) = match tokio::time::timeout(
|
||||
LOGIN_CHATGPT_TIMEOUT,
|
||||
server.block_until_done_with_callback_result(),
|
||||
@@ -750,10 +762,7 @@ impl AccountRequestProcessor {
|
||||
};
|
||||
tokio::spawn(AuthStorageOriginator::current().scope(task));
|
||||
|
||||
Ok(LoginAccountResponse::Chatgpt {
|
||||
login_id: login_id.to_string(),
|
||||
auth_url,
|
||||
})
|
||||
Ok((login_id.to_string(), auth_url))
|
||||
}
|
||||
|
||||
async fn login_chatgpt_device_code_v2(&self, request_id: ConnectionRequestId) {
|
||||
|
||||
@@ -0,0 +1,255 @@
|
||||
//! Lists the active managed login and switches its workspace through the account-session API.
|
||||
|
||||
use super::*;
|
||||
use codex_app_server_protocol::AccountSession;
|
||||
use codex_app_server_protocol::AccountSessionWorkspace;
|
||||
use codex_app_server_protocol::AccountSessionWorkspaceKind;
|
||||
use codex_app_server_protocol::AccountSessionsListParams;
|
||||
use codex_app_server_protocol::AccountSessionsResponse;
|
||||
use codex_app_server_protocol::AccountSessionsSwitchParams;
|
||||
use codex_app_server_protocol::AccountSessionsSwitchResponse;
|
||||
|
||||
impl AccountRequestProcessor {
|
||||
pub(crate) async fn list_account_sessions(
|
||||
&self,
|
||||
params: AccountSessionsListParams,
|
||||
) -> Result<AccountSessionsResponse, JSONRPCErrorError> {
|
||||
let auth = if params.refresh_workspace_metadata {
|
||||
self.auth_manager.auth().await
|
||||
} else {
|
||||
self.auth_manager.auth_cached()
|
||||
}
|
||||
.filter(|_| !self.auth_manager.has_external_auth());
|
||||
let session_id = auth
|
||||
.as_ref()
|
||||
.and_then(CodexAuth::managed_account_session_id);
|
||||
let (Some(auth), Some(session_id)) = (auth, session_id) else {
|
||||
return Ok(AccountSessionsResponse {
|
||||
active_session_id: None,
|
||||
sessions: vec![],
|
||||
});
|
||||
};
|
||||
let account_id = auth.get_account_id();
|
||||
let mut workspaces = account_id
|
||||
.iter()
|
||||
.map(|id| AccountSessionWorkspace {
|
||||
account_id: id.clone(),
|
||||
name: None,
|
||||
image_url: None,
|
||||
kind: None,
|
||||
})
|
||||
.collect();
|
||||
if params.refresh_workspace_metadata {
|
||||
let accounts = self.workspace_memberships(&auth).await?;
|
||||
workspaces = accounts
|
||||
.accounts
|
||||
.into_iter()
|
||||
.map(|account| AccountSessionWorkspace {
|
||||
account_id: account.id,
|
||||
name: account.name,
|
||||
image_url: account.profile_picture_url,
|
||||
kind: match account.structure.as_str() {
|
||||
"personal" => Some(AccountSessionWorkspaceKind::Personal),
|
||||
"workspace" => Some(AccountSessionWorkspaceKind::Workspace),
|
||||
_ => None,
|
||||
},
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
workspaces.sort_by_key(|workspace| {
|
||||
accounts
|
||||
.account_ordering
|
||||
.iter()
|
||||
.position(|id| id == &workspace.account_id)
|
||||
.unwrap_or(usize::MAX)
|
||||
});
|
||||
let current = self.auth_manager.auth_cached();
|
||||
if self.auth_manager.has_external_auth()
|
||||
|| current
|
||||
.as_ref()
|
||||
.and_then(CodexAuth::managed_account_session_id)
|
||||
.as_deref()
|
||||
!= Some(&session_id)
|
||||
|| current.and_then(|auth| auth.get_account_id()) != account_id
|
||||
{
|
||||
return Err(invalid_request(
|
||||
"Authentication changed while listing account sessions",
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(AccountSessionsResponse {
|
||||
active_session_id: Some(session_id.clone()),
|
||||
sessions: vec![AccountSession {
|
||||
session_id,
|
||||
email: auth.get_account_email(),
|
||||
user_id: auth.get_chatgpt_user_id(),
|
||||
display_name: None,
|
||||
image_url: None,
|
||||
last_used_at: chrono::Utc::now().timestamp(),
|
||||
is_active: true,
|
||||
selected_workspace_account_id: account_id,
|
||||
workspaces,
|
||||
}],
|
||||
})
|
||||
}
|
||||
|
||||
async fn workspace_memberships(
|
||||
&self,
|
||||
auth: &CodexAuth,
|
||||
) -> Result<codex_backend_client::AccountsCheckResponse, JSONRPCErrorError> {
|
||||
let client = BackendClient::from_auth(
|
||||
self.config.chatgpt_base_url.clone(),
|
||||
auth,
|
||||
self.config.http_client_factory(),
|
||||
);
|
||||
tokio::time::timeout(
|
||||
Duration::from_secs(/*secs*/ 30),
|
||||
client.get_accounts_check(),
|
||||
)
|
||||
.await
|
||||
.map_err(|_| internal_error("Workspace metadata request timed out"))?
|
||||
.map_err(|_| internal_error("Failed to fetch workspace metadata"))
|
||||
}
|
||||
|
||||
pub(crate) async fn switch_account_session(
|
||||
&self,
|
||||
params: AccountSessionsSwitchParams,
|
||||
threads: &crate::request_processors::ThreadRequestProcessor,
|
||||
admission: &crate::turn_admission::TurnAdmission,
|
||||
) -> Result<AccountSessionsSwitchResponse, JSONRPCErrorError> {
|
||||
if self.active_login.lock().await.is_some() {
|
||||
return Err(invalid_request(
|
||||
"Finish or cancel the current login before switching workspaces",
|
||||
));
|
||||
}
|
||||
self.auth_manager
|
||||
.validate_workspace_switch(¶ms.session_id, ¶ms.account_id)
|
||||
.map_err(|error| invalid_request(error.to_string()))?;
|
||||
if self
|
||||
.auth_manager
|
||||
.auth_cached()
|
||||
.and_then(|auth| auth.get_account_id())
|
||||
.as_deref()
|
||||
== Some(¶ms.account_id)
|
||||
{
|
||||
return self.account_session_switch_response(¶ms).await;
|
||||
}
|
||||
let auth = self
|
||||
.auth_manager
|
||||
.auth_cached()
|
||||
.ok_or_else(|| invalid_request("Authentication is unavailable"))?;
|
||||
let memberships = self.workspace_memberships(&auth).await?;
|
||||
let mut matches = memberships
|
||||
.accounts
|
||||
.iter()
|
||||
.filter(|account| account.id == params.account_id);
|
||||
let Some(target) = matches.next() else {
|
||||
return Err(invalid_request("The selected workspace is unavailable"));
|
||||
};
|
||||
if matches.next().is_some() || target.is_deactivated {
|
||||
return Err(invalid_request("The selected workspace is unavailable"));
|
||||
}
|
||||
// The exchange strips the FedRAMP hint from the server session's token templates.
|
||||
if auth.is_fedramp_account()
|
||||
|| target.is_fedramp_compliant_workspace
|
||||
|| target.workspace_backend_origin.as_deref() == Some("https://gov.chatgpt.com")
|
||||
{
|
||||
return Err(invalid_request("Sign in to switch government workspaces"));
|
||||
}
|
||||
self.auth_manager
|
||||
.validate_workspace_switch(¶ms.session_id, ¶ms.account_id)
|
||||
.map_err(|error| invalid_request(error.to_string()))?;
|
||||
if target.can_access_with_session == Some(false) {
|
||||
if !params.allow_browser_login {
|
||||
return Err(invalid_request(
|
||||
"The selected workspace requires a new sign-in",
|
||||
));
|
||||
}
|
||||
let mut opts = self
|
||||
.login_chatgpt_common(
|
||||
/*codex_streamlined_login*/ true,
|
||||
LoginSuccessPage::default(),
|
||||
)
|
||||
.await?;
|
||||
opts.workspace_login = Some(
|
||||
auth.workspace_login(
|
||||
¶ms.session_id,
|
||||
params.account_id.clone(),
|
||||
target.sso_connection_name.clone(),
|
||||
)
|
||||
.map_err(|error| invalid_request(error.to_string()))?,
|
||||
);
|
||||
opts.forced_chatgpt_workspace_id = Some(vec![params.account_id]);
|
||||
let pause = admission.pause().await?;
|
||||
threads.unload_for_workspace_switch().await?;
|
||||
let (login_id, auth_url) = self.start_browser_login(opts, Some(pause)).await?;
|
||||
return Ok(AccountSessionsSwitchResponse::BrowserLogin { login_id, auth_url });
|
||||
}
|
||||
let _pause = admission.pause().await?;
|
||||
threads.unload_for_workspace_switch().await?;
|
||||
let switched = self
|
||||
.auth_manager
|
||||
.switch_workspace(¶ms.session_id, ¶ms.account_id)
|
||||
.await
|
||||
.map_err(|error| invalid_request(error.to_string()))?;
|
||||
let auth_changes = self.auth_manager.auth_change_state_receiver();
|
||||
let owner_generation = auth_changes.borrow().owner_generation;
|
||||
self.reload_workspace_config().await;
|
||||
// Routing includes fatal authorization and policy checks. Restore the
|
||||
// previous login on any failure, unless another auth operation replaced it.
|
||||
if let Err(error) = self.read_account(/*request*/ None).await {
|
||||
let rollback = self.auth_manager.rollback_workspace_switch(switched).await;
|
||||
self.reload_workspace_config().await;
|
||||
rollback.map_err(|rollback| internal_error(format!("Workspace validation failed: {error}; could not restore the previous workspace: {rollback}")))?;
|
||||
return Err(internal_error(format!(
|
||||
"Workspace validation failed: {error}"
|
||||
)));
|
||||
}
|
||||
self.thread_manager.invalidate_mcp_runtimes().await;
|
||||
self.model_catalog.invalidate().await;
|
||||
Self::maybe_refresh_plugin_caches_for_current_config(
|
||||
&self.config_manager,
|
||||
&self.thread_manager,
|
||||
self.auth_manager.auth_cached(),
|
||||
)
|
||||
.await;
|
||||
self.outgoing
|
||||
.send_account_notification(
|
||||
/*connection_id*/ None,
|
||||
&auth_changes,
|
||||
owner_generation,
|
||||
AccountNotification::Updated(self.current_account_updated_notification()),
|
||||
)
|
||||
.await;
|
||||
self.account_session_switch_response(¶ms).await
|
||||
}
|
||||
|
||||
async fn reload_workspace_config(&self) {
|
||||
self.config_manager
|
||||
.update_managed_config_loader(self.auth_manager.clone(), &self.config);
|
||||
self.config_manager
|
||||
.sync_default_client_residency_requirement()
|
||||
.await;
|
||||
}
|
||||
|
||||
async fn account_session_switch_response(
|
||||
&self,
|
||||
params: &AccountSessionsSwitchParams,
|
||||
) -> Result<AccountSessionsSwitchResponse, JSONRPCErrorError> {
|
||||
let response = self
|
||||
.list_account_sessions(AccountSessionsListParams {
|
||||
refresh_workspace_metadata: false,
|
||||
})
|
||||
.await?;
|
||||
if response.active_session_id.as_deref() != Some(¶ms.session_id)
|
||||
|| !response.sessions.iter().any(|session| {
|
||||
session.session_id == params.session_id
|
||||
&& session.selected_workspace_account_id.as_deref() == Some(¶ms.account_id)
|
||||
})
|
||||
{
|
||||
return Err(invalid_request(
|
||||
"Authentication changed during workspace switching",
|
||||
));
|
||||
}
|
||||
Ok(AccountSessionsSwitchResponse::Switched { sessions: response })
|
||||
}
|
||||
}
|
||||
@@ -4,6 +4,8 @@ mod daemon_continuation;
|
||||
#[path = "daemon_snapshot.rs"]
|
||||
mod daemon_snapshot;
|
||||
|
||||
mod workspace_switching;
|
||||
|
||||
use super::persisted_resume_settings::PersistedResumeSettings;
|
||||
use super::persisted_resume_settings::latest_owned_thread_settings;
|
||||
use super::persisted_resume_settings::latest_persisted_model_settings;
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
//! Unloads old-workspace runtimes while turn admission is paused by the account switch.
|
||||
//! Resuming a thread builds fresh policy and transport state for the new workspace.
|
||||
|
||||
use super::*;
|
||||
|
||||
impl ThreadRequestProcessor {
|
||||
pub(crate) async fn unload_for_workspace_switch(&self) -> Result<(), JSONRPCErrorError> {
|
||||
let report = self
|
||||
.thread_manager
|
||||
.shutdown_all_threads_bounded(Duration::from_secs(/*secs*/ 10))
|
||||
.await;
|
||||
for thread_id in report.completed {
|
||||
self.finalize_thread_teardown(thread_id).await;
|
||||
self.outgoing
|
||||
.send_server_notification(ServerNotification::ThreadClosed(
|
||||
codex_app_server_protocol::ThreadClosedNotification {
|
||||
thread_id: thread_id.to_string(),
|
||||
},
|
||||
))
|
||||
.await;
|
||||
}
|
||||
// A delegated child may have started while its parent was shutting down.
|
||||
// Never replace credentials until every runtime has stopped.
|
||||
if !report.submit_failed.is_empty()
|
||||
|| !report.timed_out.is_empty()
|
||||
|| !self.thread_manager.list_thread_ids().await.is_empty()
|
||||
{
|
||||
return Err(internal_error(
|
||||
"Some threads are still running; retry the workspace switch",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -6,11 +6,13 @@ use std::sync::Arc;
|
||||
use std::sync::Mutex;
|
||||
use tokio::sync::watch;
|
||||
|
||||
use crate::error_code::invalid_request;
|
||||
use crate::error_code::server_draining_error;
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
struct AdmissionState {
|
||||
closed: bool,
|
||||
paused: bool,
|
||||
active: usize,
|
||||
}
|
||||
|
||||
@@ -30,8 +32,32 @@ impl Default for TurnAdmission {
|
||||
}
|
||||
|
||||
pub(crate) struct TurnPermit(TurnAdmission);
|
||||
pub(crate) struct TurnAdmissionPause(TurnAdmission);
|
||||
|
||||
impl TurnAdmission {
|
||||
pub(crate) async fn pause(&self) -> Result<TurnAdmissionPause, JSONRPCErrorError> {
|
||||
let mut active = self.subscribe_active();
|
||||
{
|
||||
let mut state = self
|
||||
.state
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
if state.closed || state.paused {
|
||||
return Err(invalid_request("Runtime changes are already paused"));
|
||||
}
|
||||
state.paused = true;
|
||||
}
|
||||
let pause = TurnAdmissionPause(self.clone());
|
||||
tokio::time::timeout(
|
||||
std::time::Duration::from_secs(/*secs*/ 10),
|
||||
active.wait_for(|active| *active == 0),
|
||||
)
|
||||
.await
|
||||
.map_err(|_| invalid_request("Work is still starting; retry the workspace switch"))?
|
||||
.map_err(|_| invalid_request("Turn admission is unavailable"))?;
|
||||
Ok(pause)
|
||||
}
|
||||
|
||||
pub(crate) fn begin_drain(&self) {
|
||||
self.state
|
||||
.lock()
|
||||
@@ -46,26 +72,38 @@ impl TurnAdmission {
|
||||
// Admit and close take the same short lock. The permit keeps shutdown from
|
||||
// finishing while an earlier request is still preparing or submitting work.
|
||||
pub(crate) fn admit(&self) -> Result<TurnPermit, JSONRPCErrorError> {
|
||||
self.try_admit().ok_or_else(server_draining_error)
|
||||
}
|
||||
|
||||
fn try_admit(&self) -> Option<TurnPermit> {
|
||||
let mut state = self
|
||||
.state
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
if state.closed {
|
||||
return None;
|
||||
return Err(server_draining_error());
|
||||
}
|
||||
if state.paused {
|
||||
return Err(invalid_request(
|
||||
"Workspace change in progress; retry when it completes",
|
||||
));
|
||||
}
|
||||
state.active += 1;
|
||||
self.active_tx.send_replace(state.active);
|
||||
Some(TurnPermit(self.clone()))
|
||||
Ok(TurnPermit(self.clone()))
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for TurnAdmissionPause {
|
||||
fn drop(&mut self) {
|
||||
self.0
|
||||
.state
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.paused = false;
|
||||
}
|
||||
}
|
||||
|
||||
impl TurnStartAdmission for TurnAdmission {
|
||||
fn admit_turn_start(&self) -> Option<Box<dyn Send>> {
|
||||
self.try_admit()
|
||||
self.admit()
|
||||
.ok()
|
||||
.map(|permit| Box::new(permit) as Box<dyn Send>)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -26,3 +26,26 @@ fn drain_rejects_new_work_without_waiting_for_admitted_work() {
|
||||
drop(automatic);
|
||||
assert_eq!(*active.borrow(), 0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn workspace_pause_waits_for_admitted_work_and_preserves_shutdown_drain() {
|
||||
let admission = TurnAdmission::default();
|
||||
let in_flight = admission.admit().unwrap();
|
||||
let pending_pause = admission.pause();
|
||||
tokio::pin!(pending_pause);
|
||||
tokio::select! {
|
||||
biased;
|
||||
_ = &mut pending_pause => panic!("pause completed before the existing request"),
|
||||
() = async {} => {}
|
||||
}
|
||||
assert!(admission.admit().is_err());
|
||||
assert!(admission.admit_turn_start().is_none());
|
||||
drop(in_flight);
|
||||
let pause = pending_pause.await.unwrap();
|
||||
drop(pause);
|
||||
drop(admission.admit().unwrap());
|
||||
let pause = admission.pause().await.unwrap();
|
||||
admission.begin_drain();
|
||||
drop(pause);
|
||||
assert!(admission.admit().is_err());
|
||||
}
|
||||
|
||||
@@ -3729,3 +3729,6 @@ async fn get_account_with_chatgpt_missing_plan_claim_returns_unknown() -> Result
|
||||
assert_eq!(received, expected);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[path = "account_workspace_switching.rs"]
|
||||
mod workspace_switching;
|
||||
|
||||
@@ -0,0 +1,520 @@
|
||||
//! Exercises workspace switching through the app-server's public account API.
|
||||
|
||||
use super::*;
|
||||
use codex_app_server_protocol::AccountSessionsResponse;
|
||||
use pretty_assertions::assert_eq;
|
||||
use test_case::test_case;
|
||||
use wiremock::matchers::body_json;
|
||||
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
enum SwitchScenario {
|
||||
Success,
|
||||
MissingWorkspace,
|
||||
DuplicateWorkspace,
|
||||
InvalidRouting,
|
||||
Unauthorized,
|
||||
PendingLogin,
|
||||
RequiresSignIn,
|
||||
BrowserSignIn,
|
||||
GovernmentWorkspace,
|
||||
}
|
||||
|
||||
#[test_case(SwitchScenario::Success; "success_and_refresh")]
|
||||
#[test_case(SwitchScenario::MissingWorkspace; "missing_workspace")]
|
||||
#[test_case(SwitchScenario::DuplicateWorkspace; "duplicate_workspace")]
|
||||
#[test_case(SwitchScenario::InvalidRouting; "invalid_routing")]
|
||||
#[test_case(SwitchScenario::Unauthorized; "unauthorized")]
|
||||
#[test_case(SwitchScenario::PendingLogin; "pending_login")]
|
||||
#[test_case(SwitchScenario::RequiresSignIn; "requires_sign_in")]
|
||||
#[test_case(SwitchScenario::BrowserSignIn; "sso_sign_in_and_cancel")]
|
||||
#[test_case(SwitchScenario::GovernmentWorkspace; "government_workspace")]
|
||||
#[tokio::test]
|
||||
async fn workspace_switch_validates_and_preserves_managed_login(
|
||||
scenario: SwitchScenario,
|
||||
) -> Result<()> {
|
||||
let home = TempDir::new()?;
|
||||
let backend = MockServer::start().await;
|
||||
Mock::given(path("/backend-api/wham/settings/user"))
|
||||
.respond_with(
|
||||
ResponseTemplate::new(200).set_body_json(json!({"commit_attribution_enabled": false})),
|
||||
)
|
||||
.mount(&backend)
|
||||
.await;
|
||||
Mock::given(path("/backend-api/wham/config/bundle"))
|
||||
.respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(json!({})))
|
||||
.mount(&backend)
|
||||
.await;
|
||||
create_config_toml(
|
||||
home.path(),
|
||||
CreateConfigTomlParams {
|
||||
requires_openai_auth: Some(true),
|
||||
base_url: Some(format!("{}/v1", backend.uri())),
|
||||
chatgpt_base_url: Some(format!("{}/backend-api", backend.uri())),
|
||||
..Default::default()
|
||||
},
|
||||
)?;
|
||||
write_models_cache(home.path()).await?;
|
||||
write_chatgpt_auth(
|
||||
home.path(),
|
||||
ChatGptAuthFixture::new("original-token")
|
||||
.email("person@example.com")
|
||||
.plan_type("plus")
|
||||
.chatgpt_user_id("user-123")
|
||||
.chatgpt_account_id(WORKSPACE_ID_INITIAL)
|
||||
.account_id(WORKSPACE_ID_INITIAL),
|
||||
AuthCredentialsStoreMode::File,
|
||||
)?;
|
||||
let original = load_file_auth(home.path())?.expect("managed auth exists");
|
||||
let inference = if scenario == SwitchScenario::Success {
|
||||
let command = json!({
|
||||
"cmd": "echo workspace-switch",
|
||||
"sandbox_permissions": "require_escalated",
|
||||
"justification": "test workspace switching during approval",
|
||||
});
|
||||
let pending = responses::sse(vec![
|
||||
responses::ev_function_call("pending-command", "exec_command", &command.to_string()),
|
||||
responses::ev_completed("old-workspace-turn"),
|
||||
]);
|
||||
Some(
|
||||
responses::mount_response_sequence(
|
||||
&backend,
|
||||
vec![
|
||||
responses::sse_response(pending)
|
||||
.insert_header("x-codex-turn-state", "old-workspace-state"),
|
||||
responses::sse_response(responses::sse_completed("new-workspace-turn")),
|
||||
],
|
||||
)
|
||||
.await,
|
||||
)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let access_token = encode_id_token(
|
||||
&ChatGptIdTokenClaims::new()
|
||||
.chatgpt_user_id("user-123")
|
||||
.chatgpt_account_id(WORKSPACE_ID_SECOND_ALLOWED)
|
||||
.plan_type("business"),
|
||||
)?;
|
||||
let rejected_before_exchange = matches!(
|
||||
scenario,
|
||||
SwitchScenario::PendingLogin
|
||||
| SwitchScenario::RequiresSignIn
|
||||
| SwitchScenario::BrowserSignIn
|
||||
| SwitchScenario::GovernmentWorkspace
|
||||
);
|
||||
Mock::given(method("POST"))
|
||||
.and(path("/backend-api/accounts/switch-workspace-token"))
|
||||
.and(header("authorization", "Bearer original-token"))
|
||||
.and(body_json(
|
||||
json!({"workspace_id": WORKSPACE_ID_SECOND_ALLOWED}),
|
||||
))
|
||||
.respond_with(
|
||||
ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"access_token": access_token})),
|
||||
)
|
||||
.expect(u64::from(!rejected_before_exchange))
|
||||
.mount(&backend)
|
||||
.await;
|
||||
let refresh_url = format!("{}/oauth/token", backend.uri());
|
||||
let source = json!({
|
||||
"id": WORKSPACE_ID_INITIAL,
|
||||
"workspace_backend_origin": "https://chatgpt.com",
|
||||
"account_routing_override": "NO_CONSTRAINT",
|
||||
});
|
||||
let mut target = json!({
|
||||
"id": WORKSPACE_ID_SECOND_ALLOWED,
|
||||
"workspace_backend_origin": "https://chatgpt.com",
|
||||
"account_routing_override": "NO_CONSTRAINT",
|
||||
"can_access_with_session": !matches!(scenario, SwitchScenario::RequiresSignIn | SwitchScenario::BrowserSignIn),
|
||||
"sso_connection_name": "test-enterprise",
|
||||
"is_fedramp_compliant_workspace": scenario == SwitchScenario::GovernmentWorkspace,
|
||||
});
|
||||
Mock::given(path("/backend-api/wham/accounts/check"))
|
||||
.and(header("chatgpt-account-id", WORKSPACE_ID_INITIAL))
|
||||
.respond_with(
|
||||
ResponseTemplate::new(200).set_body_json(json!({"accounts": [source, target]})),
|
||||
)
|
||||
.mount(&backend)
|
||||
.await;
|
||||
let target_memberships = match scenario {
|
||||
SwitchScenario::MissingWorkspace => vec![],
|
||||
SwitchScenario::DuplicateWorkspace => vec![target.clone(), target],
|
||||
SwitchScenario::InvalidRouting => {
|
||||
target["workspace_backend_origin"] = json!("invalid");
|
||||
vec![target]
|
||||
}
|
||||
_ => vec![target],
|
||||
};
|
||||
let response = if scenario == SwitchScenario::Unauthorized {
|
||||
ResponseTemplate::new(401)
|
||||
} else {
|
||||
ResponseTemplate::new(200).set_body_json(json!({"accounts": target_memberships}))
|
||||
};
|
||||
Mock::given(path("/backend-api/wham/accounts/check"))
|
||||
.and(header("chatgpt-account-id", WORKSPACE_ID_SECOND_ALLOWED))
|
||||
.respond_with(response)
|
||||
.mount(&backend)
|
||||
.await;
|
||||
let original_token = encode_id_token(
|
||||
&ChatGptIdTokenClaims::new()
|
||||
.chatgpt_user_id("user-123")
|
||||
.chatgpt_account_id(WORKSPACE_ID_INITIAL)
|
||||
.plan_type("plus"),
|
||||
)?;
|
||||
Mock::given(path("/backend-api/accounts/switch-workspace-token"))
|
||||
.and(body_json(json!({"workspace_id": WORKSPACE_ID_INITIAL})))
|
||||
.respond_with(
|
||||
ResponseTemplate::new(200).set_body_json(json!({"access_token":original_token})),
|
||||
)
|
||||
.expect(u64::from(
|
||||
!rejected_before_exchange && scenario != SwitchScenario::Success,
|
||||
))
|
||||
.mount(&backend)
|
||||
.await;
|
||||
Mock::given(path("/oauth/token"))
|
||||
.respond_with(if scenario == SwitchScenario::Unauthorized {
|
||||
ResponseTemplate::new(401).set_body_json(json!({"error": "invalid_grant"}))
|
||||
} else {
|
||||
ResponseTemplate::new(200).set_body_json(
|
||||
json!({"access_token": access_token, "refresh_token": "rotated-refresh-token"}),
|
||||
)
|
||||
})
|
||||
.mount(&backend)
|
||||
.await;
|
||||
mock_device_code_usercode(&backend, /*interval_seconds*/ 1).await;
|
||||
mock_device_code_token_failure(&backend, /*status*/ 404).await;
|
||||
let issuer = backend.uri();
|
||||
let mut app = TestAppServer::builder()
|
||||
.with_codex_home(home.path())
|
||||
.with_env_overrides(&[
|
||||
("OPENAI_API_KEY", None),
|
||||
(
|
||||
codex_login::REFRESH_TOKEN_URL_OVERRIDE_ENV_VAR,
|
||||
Some(refresh_url.as_str()),
|
||||
),
|
||||
(LOGIN_ISSUER_ENV_VAR, Some(issuer.as_str())),
|
||||
])
|
||||
.build_initialized()
|
||||
.await?;
|
||||
let id = app
|
||||
.send_request(
|
||||
"accountSession/list",
|
||||
Some(json!({
|
||||
"refreshWorkspaceMetadata": scenario == SwitchScenario::Success,
|
||||
})),
|
||||
)
|
||||
.await?;
|
||||
let listed: AccountSessionsResponse = app.read_response(id).await?;
|
||||
let session_id = listed.active_session_id.expect("active managed session");
|
||||
assert_eq!(session_id, "user-123");
|
||||
assert_eq!(listed.sessions.len(), 1);
|
||||
let session = &listed.sessions[0];
|
||||
assert_eq!(session.session_id, session_id);
|
||||
assert_eq!(session.user_id.as_deref(), Some("user-123"));
|
||||
assert_eq!(
|
||||
session.selected_workspace_account_id.as_deref(),
|
||||
Some(WORKSPACE_ID_INITIAL)
|
||||
);
|
||||
assert!(
|
||||
session
|
||||
.workspaces
|
||||
.iter()
|
||||
.any(|workspace| workspace.account_id == WORKSPACE_ID_INITIAL)
|
||||
);
|
||||
let login_id = if scenario == SwitchScenario::PendingLogin {
|
||||
let id = app.send_login_account_chatgpt_device_code_request().await?;
|
||||
let LoginAccountResponse::ChatgptDeviceCode { login_id, .. } =
|
||||
app.read_response(id).await?
|
||||
else {
|
||||
bail!("expected device login");
|
||||
};
|
||||
Some(login_id)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let thread_id = if scenario == SwitchScenario::Success {
|
||||
let id = app
|
||||
.send_thread_start_request_with_auto_env(codex_app_server_protocol::ThreadStartParams {
|
||||
model: Some("mock-model".into()),
|
||||
approval_policy: Some(codex_app_server_protocol::AskForApproval::OnRequest),
|
||||
approvals_reviewer: Some(codex_app_server_protocol::ApprovalsReviewer::User),
|
||||
sandbox: Some(codex_app_server_protocol::SandboxMode::WorkspaceWrite),
|
||||
..Default::default()
|
||||
})
|
||||
.await?;
|
||||
let thread: codex_app_server_protocol::ThreadStartResponse = app.read_response(id).await?;
|
||||
let id = app
|
||||
.send_request(
|
||||
"turn/start",
|
||||
Some(json!({
|
||||
"threadId": thread.thread.id,
|
||||
"input": [{"type": "text", "text": "Run the command"}],
|
||||
})),
|
||||
)
|
||||
.await?;
|
||||
let _: codex_app_server_protocol::TurnStartResponse = app.read_response(id).await?;
|
||||
let request = timeout(
|
||||
DEFAULT_READ_TIMEOUT,
|
||||
app.read_stream_until_request_message(),
|
||||
)
|
||||
.await??;
|
||||
assert!(matches!(
|
||||
request,
|
||||
ServerRequest::CommandExecutionRequestApproval { .. }
|
||||
));
|
||||
let _: AccountUpdatedNotification = app.read_notification("account/updated").await?;
|
||||
let id = app
|
||||
.send_request(
|
||||
"accountSession/switch",
|
||||
Some(json!({
|
||||
"sessionId": "another-session", "accountId": WORKSPACE_ID_SECOND_ALLOWED,
|
||||
})),
|
||||
)
|
||||
.await?;
|
||||
let error = app
|
||||
.read_stream_until_error_message(RequestId::Integer(id))
|
||||
.await?;
|
||||
assert!(
|
||||
error
|
||||
.error
|
||||
.message
|
||||
.contains("active managed account session")
|
||||
);
|
||||
let id = app
|
||||
.send_request("thread/loaded/list", Some(json!({})))
|
||||
.await?;
|
||||
let loaded: codex_app_server_protocol::ThreadLoadedListResponse =
|
||||
app.read_response(id).await?;
|
||||
assert_eq!(loaded.data, vec![thread.thread.id.clone()]);
|
||||
assert_eq!(load_file_auth(home.path())?, Some(original.clone()));
|
||||
Some(thread.thread.id)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let id = app
|
||||
.send_request(
|
||||
"accountSession/switch",
|
||||
Some(json!({
|
||||
"sessionId": session_id, "accountId": WORKSPACE_ID_SECOND_ALLOWED,
|
||||
"allowBrowserLogin": scenario == SwitchScenario::BrowserSignIn,
|
||||
})),
|
||||
)
|
||||
.await?;
|
||||
if scenario == SwitchScenario::BrowserSignIn {
|
||||
let response: codex_app_server_protocol::AccountSessionsSwitchResponse =
|
||||
app.read_response(id).await?;
|
||||
let codex_app_server_protocol::AccountSessionsSwitchResponse::BrowserLogin {
|
||||
login_id,
|
||||
auth_url,
|
||||
} = response
|
||||
else {
|
||||
bail!("expected browser SSO");
|
||||
};
|
||||
let url = url::Url::parse(&auth_url)?;
|
||||
let query: std::collections::HashMap<_, _> = url.query_pairs().collect();
|
||||
for (name, value) in [
|
||||
("current_workspace_id", WORKSPACE_ID_SECOND_ALLOWED),
|
||||
("allowed_workspace_id", WORKSPACE_ID_SECOND_ALLOWED),
|
||||
("login_hint", "person@example.com"),
|
||||
("connection", "test-enterprise"),
|
||||
] {
|
||||
assert_eq!(query.get(name).map(AsRef::as_ref), Some(value));
|
||||
}
|
||||
assert!(!query.contains_key("prompt"));
|
||||
assert!(!query.contains_key("reauth"));
|
||||
let id = app
|
||||
.send_cancel_login_account_request(CancelLoginAccountParams { login_id })
|
||||
.await?;
|
||||
let _: CancelLoginAccountResponse = app.read_response(id).await?;
|
||||
assert_eq!(load_file_auth(home.path())?, Some(original));
|
||||
return Ok(());
|
||||
}
|
||||
if scenario != SwitchScenario::Success {
|
||||
let error = app
|
||||
.read_stream_until_error_message(RequestId::Integer(id))
|
||||
.await?;
|
||||
let expected = match scenario {
|
||||
SwitchScenario::PendingLogin => "current login",
|
||||
SwitchScenario::RequiresSignIn => "requires a new sign-in",
|
||||
SwitchScenario::GovernmentWorkspace => "government workspaces",
|
||||
_ => "Workspace validation failed",
|
||||
};
|
||||
assert!(error.error.message.contains(expected), "{error:?}");
|
||||
assert_eq!(load_file_auth(home.path())?, Some(original));
|
||||
if let Some(login_id) = login_id {
|
||||
let id = app
|
||||
.send_cancel_login_account_request(CancelLoginAccountParams { login_id })
|
||||
.await?;
|
||||
let cancelled: CancelLoginAccountResponse = app.read_response(id).await?;
|
||||
assert_eq!(cancelled.status, CancelLoginAccountStatus::Canceled);
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
let thread_id = thread_id.expect("success scenario starts a thread");
|
||||
let closed = timeout(
|
||||
DEFAULT_READ_TIMEOUT,
|
||||
app.read_stream_until_notification_message("thread/closed"),
|
||||
)
|
||||
.await??;
|
||||
assert_eq!(
|
||||
closed.params.expect("thread/closed params")["threadId"],
|
||||
thread_id.as_str()
|
||||
);
|
||||
let interrupted: TurnCompletedNotification = app.read_notification("turn/completed").await?;
|
||||
assert_eq!(interrupted.turn.status, TurnStatus::Interrupted);
|
||||
let switched: AccountSessionsResponse =
|
||||
timeout(DEFAULT_READ_TIMEOUT, app.read_response(id)).await??;
|
||||
assert_eq!(
|
||||
switched.active_session_id.as_deref(),
|
||||
Some(session_id.as_str())
|
||||
);
|
||||
assert_eq!(
|
||||
switched.sessions[0]
|
||||
.selected_workspace_account_id
|
||||
.as_deref(),
|
||||
Some(WORKSPACE_ID_SECOND_ALLOWED)
|
||||
);
|
||||
let notification = timeout(
|
||||
DEFAULT_READ_TIMEOUT,
|
||||
app.read_stream_until_notification_message("account/updated"),
|
||||
)
|
||||
.await??;
|
||||
assert_eq!(
|
||||
serde_json::from_value::<AccountUpdatedNotification>(
|
||||
notification.params.expect("account/updated params")
|
||||
)?,
|
||||
AccountUpdatedNotification {
|
||||
auth_mode: Some(AuthMode::Chatgpt),
|
||||
plan_type: Some(AccountPlanType::Business),
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
read_account(&mut app).await?.account,
|
||||
Some(Account::Chatgpt {
|
||||
email: Some("person@example.com".into()),
|
||||
workspace_name: None,
|
||||
plan_type: AccountPlanType::Business,
|
||||
})
|
||||
);
|
||||
let mut expected = original;
|
||||
let tokens = expected.tokens.as_mut().expect("managed tokens exist");
|
||||
tokens.account_id = Some(WORKSPACE_ID_SECOND_ALLOWED.into());
|
||||
tokens.access_token = access_token;
|
||||
assert_eq!(load_file_auth(home.path())?, Some(expected.clone()));
|
||||
let id = app
|
||||
.send_request("account/read", Some(json!({"refreshToken": true})))
|
||||
.await?;
|
||||
let account: GetAccountResponse = app.read_response(id).await?;
|
||||
assert_eq!(
|
||||
account.account,
|
||||
Some(Account::Chatgpt {
|
||||
email: Some("person@example.com".into()),
|
||||
workspace_name: None,
|
||||
plan_type: AccountPlanType::Business
|
||||
})
|
||||
);
|
||||
let refreshed = load_file_auth(home.path())?.expect("managed auth exists");
|
||||
expected
|
||||
.tokens
|
||||
.as_mut()
|
||||
.expect("managed tokens exist")
|
||||
.refresh_token = "rotated-refresh-token".into();
|
||||
expected.last_refresh = refreshed.last_refresh;
|
||||
assert_eq!(refreshed, expected);
|
||||
let id = app
|
||||
.send_thread_resume_request(codex_app_server_protocol::ThreadResumeParams {
|
||||
thread_id: thread_id.clone(),
|
||||
exclude_turns: true,
|
||||
..Default::default()
|
||||
})
|
||||
.await?;
|
||||
let _: codex_app_server_protocol::ThreadResumeResponse = app.read_response(id).await?;
|
||||
let id = app
|
||||
.send_request(
|
||||
"accountSession/switch",
|
||||
Some(json!({"sessionId": session_id, "accountId": WORKSPACE_ID_SECOND_ALLOWED})),
|
||||
)
|
||||
.await?;
|
||||
let unchanged: AccountSessionsResponse = app.read_response(id).await?;
|
||||
assert_eq!(unchanged.active_session_id, Some(session_id));
|
||||
assert_eq!(
|
||||
unchanged.sessions[0]
|
||||
.selected_workspace_account_id
|
||||
.as_deref(),
|
||||
Some(WORKSPACE_ID_SECOND_ALLOWED)
|
||||
);
|
||||
let id = app
|
||||
.send_request("thread/loaded/list", Some(json!({})))
|
||||
.await?;
|
||||
let loaded: codex_app_server_protocol::ThreadLoadedListResponse = app.read_response(id).await?;
|
||||
assert_eq!(loaded.data, vec![thread_id]);
|
||||
let id = app
|
||||
.send_request(
|
||||
"turn/start",
|
||||
Some(json!({
|
||||
"threadId": loaded.data[0],
|
||||
"input": [{"type": "text", "text": "Continue in the selected workspace"}],
|
||||
})),
|
||||
)
|
||||
.await?;
|
||||
let _: codex_app_server_protocol::TurnStartResponse = app.read_response(id).await?;
|
||||
let completed: TurnCompletedNotification = timeout(
|
||||
DEFAULT_READ_TIMEOUT,
|
||||
app.read_notification("turn/completed"),
|
||||
)
|
||||
.await??;
|
||||
assert_eq!(completed.turn.status, TurnStatus::Completed);
|
||||
let requests = inference
|
||||
.expect("success scenario mounts inference")
|
||||
.requests();
|
||||
assert_eq!(requests.len(), 2);
|
||||
assert_eq!(
|
||||
requests[0].header("chatgpt-account-id"),
|
||||
Some(WORKSPACE_ID_INITIAL.into())
|
||||
);
|
||||
assert_eq!(
|
||||
requests[1].header("chatgpt-account-id"),
|
||||
Some(WORKSPACE_ID_SECOND_ALLOWED.into())
|
||||
);
|
||||
assert_eq!(requests[1].header("x-codex-turn-state"), None);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn account_session_list_is_empty_without_a_managed_chatgpt_login() -> Result<()> {
|
||||
let home = TempDir::new()?;
|
||||
let mut app = TestAppServer::builder()
|
||||
.with_codex_home(home.path())
|
||||
.with_env_overrides(&[("OPENAI_API_KEY", None)])
|
||||
.build_initialized()
|
||||
.await?;
|
||||
for api_key in [None, Some("test-api-key")] {
|
||||
if let Some(api_key) = api_key {
|
||||
let id = app
|
||||
.send_request(
|
||||
"account/login/start",
|
||||
Some(json!({
|
||||
"type": "apiKey", "apiKey": api_key,
|
||||
})),
|
||||
)
|
||||
.await?;
|
||||
let _: LoginAccountResponse = app.read_response(id).await?;
|
||||
}
|
||||
let id = app
|
||||
.send_request(
|
||||
"accountSession/list",
|
||||
Some(json!({
|
||||
"refreshWorkspaceMetadata": true,
|
||||
})),
|
||||
)
|
||||
.await?;
|
||||
let response: AccountSessionsResponse = app.read_response(id).await?;
|
||||
assert_eq!(
|
||||
response,
|
||||
AccountSessionsResponse {
|
||||
active_session_id: None,
|
||||
sessions: vec![]
|
||||
}
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -136,6 +136,12 @@ pub struct AccountsCheckResponse {
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
pub struct AccountEntry {
|
||||
pub id: String,
|
||||
pub can_access_with_session: Option<bool>,
|
||||
pub sso_connection_name: Option<String>,
|
||||
#[serde(default)]
|
||||
pub is_deactivated: bool,
|
||||
#[serde(default)]
|
||||
pub is_fedramp_compliant_workspace: bool,
|
||||
/// Current subscription reported by the accounts endpoint, independent of token claims.
|
||||
#[serde(default)]
|
||||
pub plan_type: Option<codex_protocol::account::PlanType>,
|
||||
@@ -175,12 +181,18 @@ impl Default for RawAccounts {
|
||||
#[derive(Deserialize)]
|
||||
struct ChatGptAccountEntry {
|
||||
account: ChatGptAccountInfo,
|
||||
can_access_with_session: Option<bool>,
|
||||
sso_connection_name: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct ChatGptAccountInfo {
|
||||
account_id: Option<String>,
|
||||
#[serde(default)]
|
||||
is_deactivated: bool,
|
||||
#[serde(default)]
|
||||
is_fedramp_compliant_workspace: bool,
|
||||
#[serde(default)]
|
||||
plan_type: Option<codex_protocol::account::PlanType>,
|
||||
#[serde(default)]
|
||||
name: Option<String>,
|
||||
@@ -202,9 +214,14 @@ impl<'de> Deserialize<'de> for AccountsCheckResponse {
|
||||
.account_ordering
|
||||
.iter()
|
||||
.filter_map(|account_id| {
|
||||
let account = accounts.remove(account_id)?.account;
|
||||
let entry = accounts.remove(account_id)?;
|
||||
let account = entry.account;
|
||||
Some(AccountEntry {
|
||||
id: account.account_id?,
|
||||
can_access_with_session: entry.can_access_with_session,
|
||||
sso_connection_name: entry.sso_connection_name,
|
||||
is_deactivated: account.is_deactivated,
|
||||
is_fedramp_compliant_workspace: account.is_fedramp_compliant_workspace,
|
||||
plan_type: account.plan_type,
|
||||
workspace_backend_origin: None,
|
||||
account_routing_override: None,
|
||||
|
||||
@@ -1187,6 +1187,19 @@ async fn loads_api_key_from_auth_json() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn logout_does_not_create_a_missing_file_store() -> std::io::Result<()> {
|
||||
let root = tempdir()?;
|
||||
let missing_home = root.path().join("missing");
|
||||
assert!(!logout(
|
||||
&missing_home,
|
||||
AuthCredentialsStoreMode::File,
|
||||
AuthKeyringBackendKind::default()
|
||||
)?);
|
||||
assert!(!missing_home.exists());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn logout_removes_auth_file() -> Result<(), std::io::Error> {
|
||||
let dir = tempdir()?;
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
mod workspace_routing;
|
||||
mod workspace_switching;
|
||||
pub use workspace_switching::WorkspaceLogin;
|
||||
pub use workspace_switching::WorkspaceSwitch;
|
||||
|
||||
#[path = "account_grant.rs"]
|
||||
mod account_grant;
|
||||
@@ -604,7 +607,7 @@ impl CodexAuth {
|
||||
tokens: Some(tokens),
|
||||
last_refresh: Some(_),
|
||||
..
|
||||
}) => Ok(tokens),
|
||||
}) => Ok(workspace_switching::selected_workspace_tokens(tokens)),
|
||||
_ => Err(std::io::Error::other("Token data is not available.")),
|
||||
}
|
||||
}
|
||||
@@ -738,7 +741,9 @@ impl CodexAuth {
|
||||
|
||||
/// Returns `None` if token-backed ChatGPT auth is unavailable.
|
||||
fn get_current_token_data(&self) -> Option<TokenData> {
|
||||
self.get_current_auth_json().and_then(|t| t.tokens)
|
||||
self.get_current_auth_json()
|
||||
.and_then(|t| t.tokens)
|
||||
.map(workspace_switching::selected_workspace_tokens)
|
||||
}
|
||||
|
||||
fn stored_managed_chatgpt_agent_identity_record(
|
||||
@@ -960,13 +965,12 @@ fn persist_agent_identity_record(
|
||||
storage: &Arc<dyn AuthStorageBackend>,
|
||||
record: AgentIdentityAuthRecord,
|
||||
) -> std::io::Result<()> {
|
||||
let _commit = auth_storage_commit_guard()?;
|
||||
let _commit = storage.lock_for_write()?;
|
||||
let mut guard = auth_dot_json
|
||||
.lock()
|
||||
.map_err(|_| std::io::Error::other("failed to lock auth state"))?;
|
||||
let stored = storage.load()?;
|
||||
if let Some(previous) = guard.as_ref().and_then(|auth| auth.tokens.as_ref())
|
||||
&& previous.login_owner_id.is_some()
|
||||
&& !stored
|
||||
.as_ref()
|
||||
.and_then(|auth| auth.tokens.as_ref())
|
||||
@@ -976,9 +980,7 @@ fn persist_agent_identity_record(
|
||||
"Account changed during agent identity registration.",
|
||||
));
|
||||
}
|
||||
let mut auth = stored
|
||||
.or_else(|| guard.clone())
|
||||
.ok_or_else(|| std::io::Error::other("auth data is not available"))?;
|
||||
let mut auth = stored.ok_or_else(|| std::io::Error::other("auth data is not available"))?;
|
||||
auth.agent_identity = Some(AgentIdentityStorage::Record(record));
|
||||
storage.save(&auth)?;
|
||||
// Publishing credentials belongs to AuthManager. Persisting identity metadata must
|
||||
@@ -1022,12 +1024,15 @@ pub fn logout(
|
||||
auth_credentials_store_mode: AuthCredentialsStoreMode,
|
||||
keyring_backend_kind: AuthKeyringBackendKind,
|
||||
) -> std::io::Result<bool> {
|
||||
let _commit = auth_storage_commit_guard()?;
|
||||
if auth_credentials_store_mode == AuthCredentialsStoreMode::File && !codex_home.try_exists()? {
|
||||
return Ok(false);
|
||||
}
|
||||
let storage = create_auth_storage(
|
||||
codex_home.to_path_buf(),
|
||||
auth_credentials_store_mode,
|
||||
keyring_backend_kind,
|
||||
);
|
||||
let _commit = storage.lock_for_write()?;
|
||||
storage.delete()
|
||||
}
|
||||
|
||||
@@ -1193,12 +1198,12 @@ pub fn save_auth(
|
||||
auth_credentials_store_mode: AuthCredentialsStoreMode,
|
||||
keyring_backend_kind: AuthKeyringBackendKind,
|
||||
) -> std::io::Result<()> {
|
||||
let _commit = auth_storage_commit_guard()?;
|
||||
let storage = create_auth_storage(
|
||||
codex_home.to_path_buf(),
|
||||
auth_credentials_store_mode,
|
||||
keyring_backend_kind,
|
||||
);
|
||||
let _commit = storage.lock_for_write()?;
|
||||
storage.save(auth)
|
||||
}
|
||||
|
||||
@@ -1658,7 +1663,7 @@ pub(super) fn persist_tokens(
|
||||
access_token: Option<String>,
|
||||
refresh_token: Option<String>,
|
||||
) -> std::io::Result<AuthDotJson> {
|
||||
let _commit = auth_storage_commit_guard()?;
|
||||
let _commit = storage.lock_for_write()?;
|
||||
let stored = storage.load()?;
|
||||
let mut auth_dot_json = stored.ok_or(std::io::Error::other("Token data is not available."))?;
|
||||
if auth_dot_json.resolved_mode() != AuthMode::Chatgpt {
|
||||
|
||||
@@ -0,0 +1,370 @@
|
||||
//! Switches the workspace of managed ChatGPT auth without a new login.
|
||||
//! Refresh credentials remain owned by the existing auth store.
|
||||
|
||||
use super::*;
|
||||
use codex_http_client::ClientRouteClass;
|
||||
use codex_http_client::RouteAwareClientPool;
|
||||
use serde_json::json;
|
||||
use std::io;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct WorkspaceTokenResponse {
|
||||
access_token: String,
|
||||
}
|
||||
|
||||
/// Allows the caller to restore credentials if target workspace validation fails.
|
||||
/// Restoration is conditional so it cannot overwrite a newer login or logout.
|
||||
pub struct WorkspaceSwitch {
|
||||
storage: Arc<dyn AuthStorageBackend>,
|
||||
previous: AuthDotJson,
|
||||
selected: AuthDotJson,
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for WorkspaceSwitch {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("WorkspaceSwitch").finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
/// Binds a browser callback to the managed login that requested the workspace.
|
||||
#[derive(Clone)]
|
||||
pub struct WorkspaceLogin {
|
||||
storage: Arc<dyn AuthStorageBackend>,
|
||||
original: AuthDotJson,
|
||||
pub(crate) workspace_id: String,
|
||||
pub(crate) email: Option<String>,
|
||||
pub(crate) connection: Option<String>,
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for WorkspaceLogin {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("WorkspaceLogin").finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
impl WorkspaceLogin {
|
||||
pub(crate) fn save(&self, mut updated: AuthDotJson) -> io::Result<()> {
|
||||
let previous = self
|
||||
.original
|
||||
.tokens
|
||||
.as_ref()
|
||||
.ok_or_else(|| io::Error::other("Missing managed login"))?;
|
||||
let tokens = updated
|
||||
.tokens
|
||||
.as_mut()
|
||||
.ok_or_else(|| io::Error::other("Missing sign-in credentials"))?;
|
||||
let access = parse_chatgpt_jwt_claims(&tokens.access_token).map_err(io::Error::other)?;
|
||||
if previous.id_token.chatgpt_user_id.is_none()
|
||||
|| tokens.id_token.chatgpt_user_id != previous.id_token.chatgpt_user_id
|
||||
|| access.chatgpt_user_id != previous.id_token.chatgpt_user_id
|
||||
|| tokens.account_id.as_deref() != Some(&self.workspace_id)
|
||||
|| access.chatgpt_account_id != tokens.account_id
|
||||
{
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::PermissionDenied,
|
||||
"Sign-in returned a different user or workspace",
|
||||
));
|
||||
}
|
||||
tokens.login_owner_id.clone_from(&previous.login_owner_id);
|
||||
replace_if_current(self.storage.as_ref(), &self.original, &updated)
|
||||
}
|
||||
}
|
||||
|
||||
impl CodexAuth {
|
||||
pub fn workspace_login(
|
||||
&self,
|
||||
session_id: &str,
|
||||
workspace_id: String,
|
||||
connection: Option<String>,
|
||||
) -> io::Result<WorkspaceLogin> {
|
||||
let Self::Chatgpt(auth) = self else {
|
||||
return Err(io::Error::other(
|
||||
"Workspace sign-in requires a managed login",
|
||||
));
|
||||
};
|
||||
let original = auth
|
||||
.current_auth_json()
|
||||
.ok_or_else(|| io::Error::other("Missing managed login"))?;
|
||||
if original.tokens.as_ref().and_then(managed_session_id) != Some(session_id) {
|
||||
return Err(io::Error::other("The active login changed"));
|
||||
}
|
||||
Ok(WorkspaceLogin {
|
||||
storage: auth.storage().clone(),
|
||||
original,
|
||||
workspace_id,
|
||||
email: self.get_account_email(),
|
||||
connection,
|
||||
})
|
||||
}
|
||||
|
||||
/// Stable across token rotation and workspace changes for the managed login.
|
||||
pub fn managed_account_session_id(&self) -> Option<String> {
|
||||
if !matches!(self, Self::Chatgpt(_)) {
|
||||
return None;
|
||||
}
|
||||
let tokens = self.get_current_token_data()?;
|
||||
managed_session_id(&tokens).map(str::to_owned)
|
||||
}
|
||||
}
|
||||
|
||||
impl AuthManager {
|
||||
/// Checks local eligibility without changing credentials or an in-progress login.
|
||||
pub fn validate_workspace_switch(
|
||||
&self,
|
||||
session_id: &str,
|
||||
workspace_id: &str,
|
||||
) -> io::Result<()> {
|
||||
if workspace_id.trim().is_empty() {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
"accountId must not be empty",
|
||||
));
|
||||
}
|
||||
ensure_auth_workspace_allowed(
|
||||
self.effective_chatgpt_workspaces().as_deref(),
|
||||
workspace_id,
|
||||
)?;
|
||||
let auth = self.auth_cached();
|
||||
if !matches!(auth, Some(CodexAuth::Chatgpt(_))) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::Unsupported,
|
||||
"Workspace switching requires a managed ChatGPT login",
|
||||
));
|
||||
}
|
||||
if self.has_external_auth() {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::Unsupported,
|
||||
"Workspace switching is owned by the external authentication provider",
|
||||
));
|
||||
}
|
||||
if auth
|
||||
.and_then(|auth| auth.managed_account_session_id())
|
||||
.as_deref()
|
||||
!= Some(session_id)
|
||||
{
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
"Only the active managed account session can be switched",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Exchanges the current session into another workspace without exporting credentials.
|
||||
pub async fn switch_workspace(
|
||||
&self,
|
||||
session_id: &str,
|
||||
workspace_id: &str,
|
||||
) -> io::Result<WorkspaceSwitch> {
|
||||
self.validate_workspace_switch(session_id, workspace_id)?;
|
||||
self.auth().await;
|
||||
let _guard = self
|
||||
.refresh_lock
|
||||
.acquire()
|
||||
.await
|
||||
.map_err(io::Error::other)?;
|
||||
self.validate_workspace_switch(session_id, workspace_id)?;
|
||||
let Some(CodexAuth::Chatgpt(auth)) = self.auth_cached() else {
|
||||
return Err(io::Error::other("Authentication is unavailable"));
|
||||
};
|
||||
let snapshot = auth
|
||||
.current_auth_json()
|
||||
.ok_or_else(|| io::Error::other("Authentication is unavailable"))?;
|
||||
let tokens = snapshot
|
||||
.tokens
|
||||
.as_ref()
|
||||
.ok_or_else(|| io::Error::other("Authentication is unavailable"))?;
|
||||
let user_id = tokens
|
||||
.id_token
|
||||
.chatgpt_user_id
|
||||
.as_deref()
|
||||
.filter(|id| !id.is_empty())
|
||||
.ok_or_else(|| io::Error::other("Authentication is missing a user identity"))?;
|
||||
// reload() may replace cached auth without the refresh lock. Bind the
|
||||
// request to the exact snapshot used by both the exchange and conditional save.
|
||||
if managed_session_id(tokens) != Some(session_id) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
"Only the active managed account session can be switched",
|
||||
));
|
||||
}
|
||||
if tokens.account_id.as_deref() == Some(workspace_id) {
|
||||
return Ok(WorkspaceSwitch {
|
||||
storage: auth.storage().clone(),
|
||||
previous: snapshot.clone(),
|
||||
selected: snapshot,
|
||||
});
|
||||
}
|
||||
let access_token = self
|
||||
.exchange_workspace_token(&tokens.access_token, workspace_id, user_id)
|
||||
.await?;
|
||||
ensure_auth_workspace_allowed(
|
||||
self.effective_chatgpt_workspaces().as_deref(),
|
||||
workspace_id,
|
||||
)?;
|
||||
if self.has_external_auth() {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::Interrupted,
|
||||
"Authentication changed during workspace switching",
|
||||
));
|
||||
}
|
||||
let mut updated = snapshot.clone();
|
||||
let tokens = updated
|
||||
.tokens
|
||||
.as_mut()
|
||||
.ok_or_else(|| io::Error::other("Authentication is unavailable"))?;
|
||||
tokens.access_token = access_token;
|
||||
tokens.account_id = Some(workspace_id.to_owned());
|
||||
// The exchange does not renew the session or issue refresh/ID tokens.
|
||||
updated.agent_identity = None;
|
||||
replace_if_current(auth.storage().as_ref(), &snapshot, &updated)?;
|
||||
self.reload().await;
|
||||
Ok(WorkspaceSwitch {
|
||||
storage: auth.storage().clone(),
|
||||
previous: snapshot,
|
||||
selected: updated,
|
||||
})
|
||||
}
|
||||
|
||||
/// Restores a rejected workspace change only while its credentials are still current.
|
||||
pub async fn rollback_workspace_switch(&self, switched: WorkspaceSwitch) -> io::Result<()> {
|
||||
let _guard = self
|
||||
.refresh_lock
|
||||
.acquire()
|
||||
.await
|
||||
.map_err(io::Error::other)?;
|
||||
if self.has_external_auth()
|
||||
|| switched.storage.load_account_grant()?.as_ref() != Some(&switched.selected)
|
||||
{
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::Interrupted,
|
||||
"Account credentials changed",
|
||||
));
|
||||
}
|
||||
let selected = switched
|
||||
.selected
|
||||
.tokens
|
||||
.as_ref()
|
||||
.ok_or_else(|| io::Error::other("Missing selected credentials"))?;
|
||||
let previous_workspace = switched
|
||||
.previous
|
||||
.tokens
|
||||
.as_ref()
|
||||
.and_then(|tokens| tokens.account_id.as_deref())
|
||||
.ok_or_else(|| io::Error::other("Missing previous workspace"))?;
|
||||
let user = selected
|
||||
.id_token
|
||||
.chatgpt_user_id
|
||||
.as_deref()
|
||||
.ok_or_else(|| io::Error::other("Missing selected user"))?;
|
||||
// The exchange also selects the workspace used by the server on the next refresh.
|
||||
self.exchange_workspace_token(&selected.access_token, previous_workspace, user)
|
||||
.await?;
|
||||
let result = replace_if_current(
|
||||
switched.storage.as_ref(),
|
||||
&switched.selected,
|
||||
&switched.previous,
|
||||
);
|
||||
self.reload().await;
|
||||
result
|
||||
}
|
||||
|
||||
pub(super) async fn exchange_workspace_token(
|
||||
&self,
|
||||
access_token: &str,
|
||||
workspace_id: &str,
|
||||
user_id: &str,
|
||||
) -> io::Result<String> {
|
||||
let base_url = self
|
||||
.chatgpt_base_url
|
||||
.as_deref()
|
||||
.unwrap_or(ChatGptEnvironment::default().chatgpt_base_url())
|
||||
.trim_end_matches('/');
|
||||
let endpoint = format!("{base_url}/accounts/switch-workspace-token");
|
||||
let client = RouteAwareClientPool::with_chatgpt_cloudflare_cookies_without_redirects_or_request_logging(
|
||||
self.auth_route_config.http_client_factory().clone(), ClientRouteClass::Auth,
|
||||
);
|
||||
let response = client
|
||||
.post(&endpoint)
|
||||
.headers(crate::default_client::default_headers())
|
||||
.header(
|
||||
http::header::AUTHORIZATION,
|
||||
format!("Bearer {access_token}"),
|
||||
)
|
||||
.json(&json!({ "workspace_id": workspace_id }))
|
||||
.timeout(Duration::from_secs(/*secs*/ 30))
|
||||
.send()
|
||||
.await
|
||||
.map_err(io::Error::other)?;
|
||||
if !response.status().is_success() {
|
||||
let kind = if response.status().is_client_error() {
|
||||
io::ErrorKind::PermissionDenied
|
||||
} else {
|
||||
io::ErrorKind::Other
|
||||
};
|
||||
return Err(io::Error::new(
|
||||
kind,
|
||||
format!("Workspace switch was rejected (HTTP {})", response.status()),
|
||||
));
|
||||
}
|
||||
let response: WorkspaceTokenResponse = response.json().await.map_err(io::Error::other)?;
|
||||
let claims = parse_chatgpt_jwt_claims(&response.access_token).map_err(io::Error::other)?;
|
||||
if claims.chatgpt_account_id.as_deref() != Some(workspace_id)
|
||||
|| claims.chatgpt_user_id.as_deref() != Some(user_id)
|
||||
{
|
||||
return Err(io::Error::other(
|
||||
"Workspace exchange returned a different user or workspace",
|
||||
));
|
||||
}
|
||||
Ok(response.access_token)
|
||||
}
|
||||
}
|
||||
|
||||
// Older credentials predate login_owner_id. Keep them usable without migrating the store.
|
||||
fn managed_session_id(tokens: &TokenData) -> Option<&str> {
|
||||
let user_id = tokens
|
||||
.id_token
|
||||
.chatgpt_user_id
|
||||
.as_deref()
|
||||
.filter(|id| !id.is_empty())?;
|
||||
Some(
|
||||
tokens
|
||||
.login_owner_id
|
||||
.as_deref()
|
||||
.filter(|id| !id.is_empty())
|
||||
.unwrap_or(user_id),
|
||||
)
|
||||
}
|
||||
|
||||
fn replace_if_current(
|
||||
storage: &dyn AuthStorageBackend,
|
||||
expected: &AuthDotJson,
|
||||
updated: &AuthDotJson,
|
||||
) -> io::Result<()> {
|
||||
let _commit = storage.lock_for_write()?;
|
||||
if storage.load_account_grant()?.as_ref() != Some(expected) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::Interrupted,
|
||||
"Account credentials changed",
|
||||
));
|
||||
}
|
||||
storage.save(updated)
|
||||
}
|
||||
|
||||
/// The retained ID token can still describe the previous workspace until refresh.
|
||||
pub(super) fn selected_workspace_tokens(mut tokens: TokenData) -> TokenData {
|
||||
if tokens.account_id != tokens.id_token.chatgpt_account_id
|
||||
&& let Ok(claims) = parse_chatgpt_jwt_claims(&tokens.access_token)
|
||||
&& claims.chatgpt_account_id == tokens.account_id
|
||||
&& claims.chatgpt_user_id == tokens.id_token.chatgpt_user_id
|
||||
{
|
||||
tokens.id_token.chatgpt_account_id = claims.chatgpt_account_id;
|
||||
tokens.id_token.chatgpt_plan_type = claims.chatgpt_plan_type;
|
||||
tokens.id_token.chatgpt_account_is_fedramp = claims.chatgpt_account_is_fedramp;
|
||||
}
|
||||
tokens
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "workspace_switching_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,354 @@
|
||||
#![cfg(test)]
|
||||
|
||||
//! Verifies workspace exchange persistence and failed-switch isolation.
|
||||
|
||||
use super::*;
|
||||
use base64::Engine;
|
||||
use pretty_assertions::assert_eq;
|
||||
use tempfile::TempDir;
|
||||
use wiremock::Mock;
|
||||
use wiremock::MockServer;
|
||||
use wiremock::ResponseTemplate;
|
||||
use wiremock::matchers::body_json;
|
||||
use wiremock::matchers::header;
|
||||
use wiremock::matchers::method;
|
||||
use wiremock::matchers::path;
|
||||
|
||||
fn token(workspace: &str, user: &str, plan: &str) -> String {
|
||||
let claims = json!({
|
||||
"exp": (Utc::now() + chrono::Duration::hours(/*hours*/ 1)).timestamp(),
|
||||
"email": "person@example.com",
|
||||
"https://api.openai.com/auth": {
|
||||
"chatgpt_account_id": workspace,
|
||||
"chatgpt_user_id": user,
|
||||
"chatgpt_plan_type": plan,
|
||||
},
|
||||
});
|
||||
let encoded = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(claims.to_string());
|
||||
format!("e30.{encoded}.signature")
|
||||
}
|
||||
|
||||
async fn session(server: &MockServer) -> anyhow::Result<(TempDir, AuthManager, AuthDotJson)> {
|
||||
let home = tempfile::tempdir()?;
|
||||
let jwt = token("personal", "user-1", "plus");
|
||||
let snapshot = AuthDotJson {
|
||||
auth_mode: Some(AuthMode::Chatgpt),
|
||||
openai_api_key: None,
|
||||
tokens: Some(TokenData {
|
||||
id_token: parse_chatgpt_jwt_claims(&jwt)?,
|
||||
access_token: jwt,
|
||||
refresh_token: "retained-refresh-token".into(),
|
||||
account_id: Some("personal".into()),
|
||||
login_owner_id: Some("login-1".into()),
|
||||
oauth_provenance: None,
|
||||
}),
|
||||
last_refresh: Some(Utc::now()),
|
||||
agent_identity: None,
|
||||
personal_access_token: None,
|
||||
bedrock_api_key: None,
|
||||
bedrock_access_keys: None,
|
||||
};
|
||||
create_auth_storage(
|
||||
home.path().to_path_buf(),
|
||||
AuthCredentialsStoreMode::File,
|
||||
AuthKeyringBackendKind::default(),
|
||||
)
|
||||
.save(&snapshot)?;
|
||||
let manager = AuthManager::new(
|
||||
home.path().to_path_buf(),
|
||||
/*enable_codex_api_key_env*/ false,
|
||||
AuthCredentialsStoreMode::File,
|
||||
/*forced_chatgpt_workspace_id*/ None,
|
||||
Some(server.uri()),
|
||||
AuthKeyringBackendKind::default(),
|
||||
crate::test_support::transport_default_auth_route_config(),
|
||||
)
|
||||
.await;
|
||||
Ok((home, manager, snapshot))
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn workspace_switch_preserves_login_and_survives_reload() -> anyhow::Result<()> {
|
||||
let server = MockServer::start().await;
|
||||
let (home, manager, snapshot) = session(&server).await?;
|
||||
let access_token = token("business", "user-1", "business");
|
||||
Mock::given(method("POST"))
|
||||
.and(path("/accounts/switch-workspace-token"))
|
||||
.and(header(
|
||||
"authorization",
|
||||
format!("Bearer {}", snapshot.tokens.as_ref().unwrap().access_token),
|
||||
))
|
||||
.and(body_json(json!({"workspace_id": "business"})))
|
||||
.respond_with(
|
||||
ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"access_token": access_token})),
|
||||
)
|
||||
.expect(/*r*/ 1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
let before = *manager.auth_change_state_receiver().borrow();
|
||||
manager.switch_workspace("login-1", "business").await?;
|
||||
enforce_login_restrictions(&AuthConfig {
|
||||
codex_home: home.path().to_path_buf(),
|
||||
auth_credentials_store_mode: AuthCredentialsStoreMode::File,
|
||||
keyring_backend_kind: AuthKeyringBackendKind::default(),
|
||||
forced_login_method: None,
|
||||
forced_chatgpt_workspace_id: Some(vec!["business".into()]),
|
||||
managed_auth_policy: ManagedAuthPolicy::default(),
|
||||
chatgpt_base_url: Some(server.uri()),
|
||||
auth_route_config: crate::test_support::transport_default_auth_route_config(),
|
||||
})
|
||||
.await?;
|
||||
manager.reload().await;
|
||||
let auth = manager.auth_cached().unwrap();
|
||||
let mut expected = snapshot.clone();
|
||||
let tokens = expected.tokens.as_mut().unwrap();
|
||||
tokens.access_token = access_token;
|
||||
tokens.account_id = Some("business".into());
|
||||
assert_eq!(auth.get_current_auth_json(), Some(expected));
|
||||
assert_eq!(
|
||||
(
|
||||
auth.get_account_id(),
|
||||
auth.get_chatgpt_user_id(),
|
||||
auth.account_plan_type()
|
||||
),
|
||||
(
|
||||
Some("business".into()),
|
||||
Some("user-1".into()),
|
||||
Some(AccountPlanType::Business)
|
||||
),
|
||||
);
|
||||
assert!(
|
||||
manager
|
||||
.auth_change_state_receiver()
|
||||
.borrow()
|
||||
.owner_generation
|
||||
> before.owner_generation
|
||||
);
|
||||
manager.switch_workspace("login-1", "business").await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn workspace_switch_rejects_stale_agent_identity_and_rolls_back_conditionally()
|
||||
-> anyhow::Result<()> {
|
||||
let server = MockServer::start().await;
|
||||
let (_home, manager, snapshot) = session(&server).await?;
|
||||
let original_auth = manager.auth_cached().unwrap();
|
||||
Mock::given(method("POST"))
|
||||
.respond_with(
|
||||
ResponseTemplate::new(/*s*/ 200)
|
||||
.set_body_json(json!({"access_token": token("business", "user-1", "business")})),
|
||||
)
|
||||
.mount(&server)
|
||||
.await;
|
||||
Mock::given(method("POST"))
|
||||
.and(body_json(json!({"workspace_id": "personal"})))
|
||||
.respond_with(
|
||||
ResponseTemplate::new(200)
|
||||
.set_body_json(json!({"access_token": token("personal", "user-1", "plus")})),
|
||||
)
|
||||
.with_priority(1)
|
||||
.expect(1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
let switched = manager.switch_workspace("login-1", "business").await?;
|
||||
let selected = manager.auth_cached().unwrap().get_current_auth_json();
|
||||
let error = original_auth
|
||||
.persist_managed_chatgpt_agent_identity_record(AgentIdentityAuthRecord {
|
||||
agent_runtime_id: "runtime-personal".into(),
|
||||
agent_private_key: "private-key-personal".into(),
|
||||
account_id: "personal".into(),
|
||||
chatgpt_user_id: "user-1".into(),
|
||||
email: None,
|
||||
plan_type: AccountPlanType::Plus,
|
||||
chatgpt_account_is_fedramp: false,
|
||||
task_id: None,
|
||||
})
|
||||
.unwrap_err();
|
||||
assert!(error.to_string().contains("Account changed"));
|
||||
manager.reload().await;
|
||||
assert_eq!(
|
||||
manager.auth_cached().unwrap().get_current_auth_json(),
|
||||
selected
|
||||
);
|
||||
manager.rollback_workspace_switch(switched).await?;
|
||||
assert_eq!(
|
||||
manager.auth_cached().unwrap().get_current_auth_json(),
|
||||
Some(snapshot)
|
||||
);
|
||||
let switched = manager.switch_workspace("login-1", "business").await?;
|
||||
manager.logout().await?;
|
||||
assert_eq!(
|
||||
manager
|
||||
.rollback_workspace_switch(switched)
|
||||
.await
|
||||
.unwrap_err()
|
||||
.kind(),
|
||||
io::ErrorKind::Interrupted
|
||||
);
|
||||
assert!(manager.auth_cached().is_none());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn workspace_switch_rejection_preserves_current_login() -> anyhow::Result<()> {
|
||||
for (status, response) in [
|
||||
(
|
||||
403,
|
||||
json!({"error": {"code": "invalid_workspace_selected"}}),
|
||||
),
|
||||
(
|
||||
200,
|
||||
json!({"access_token": token("business", "another-user", "business")}),
|
||||
),
|
||||
(
|
||||
200,
|
||||
json!({"access_token": token("wrong-workspace", "user-1", "business")}),
|
||||
),
|
||||
] {
|
||||
let server = MockServer::start().await;
|
||||
let (_home, manager, snapshot) = session(&server).await?;
|
||||
Mock::given(method("POST"))
|
||||
.respond_with(ResponseTemplate::new(status).set_body_json(response))
|
||||
.expect(/*r*/ 1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
assert!(
|
||||
manager
|
||||
.switch_workspace("login-1", "business")
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
manager.reload().await;
|
||||
assert_eq!(
|
||||
manager.auth_cached().unwrap().get_current_auth_json(),
|
||||
Some(snapshot)
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn workspace_switch_obeys_workspace_policy() -> anyhow::Result<()> {
|
||||
let server = MockServer::start().await;
|
||||
let (_home, manager, snapshot) = session(&server).await?;
|
||||
manager.set_forced_chatgpt_workspace_id(Some(vec!["personal".into()]));
|
||||
assert_eq!(
|
||||
manager
|
||||
.switch_workspace("login-1", "business")
|
||||
.await
|
||||
.unwrap_err()
|
||||
.kind(),
|
||||
io::ErrorKind::PermissionDenied
|
||||
);
|
||||
assert!(server.received_requests().await.unwrap().is_empty());
|
||||
assert_eq!(
|
||||
manager.auth_cached().unwrap().get_current_auth_json(),
|
||||
Some(snapshot)
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn workspace_switch_does_not_restore_a_logged_out_session() -> anyhow::Result<()> {
|
||||
let server = MockServer::start().await;
|
||||
let (home, manager, _) = session(&server).await?;
|
||||
let received = Arc::new(tokio::sync::Notify::new());
|
||||
let notify = received.clone();
|
||||
Mock::given(method("POST"))
|
||||
.respond_with(move |_: &wiremock::Request| {
|
||||
notify.notify_one();
|
||||
ResponseTemplate::new(/*s*/ 200)
|
||||
.set_body_json(json!({"access_token": token("business", "user-1", "business")}))
|
||||
.set_delay(Duration::from_millis(/*millis*/ 100))
|
||||
})
|
||||
.expect(/*r*/ 1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
let (switched, logged_out) =
|
||||
tokio::join!(manager.switch_workspace("login-1", "business"), async {
|
||||
received.notified().await;
|
||||
manager.logout().await
|
||||
},);
|
||||
logged_out?;
|
||||
assert_eq!(switched.unwrap_err().kind(), io::ErrorKind::Interrupted);
|
||||
assert!(manager.auth_cached().is_none());
|
||||
assert!(
|
||||
create_auth_storage(
|
||||
home.path().to_path_buf(),
|
||||
AuthCredentialsStoreMode::File,
|
||||
AuthKeyringBackendKind::default()
|
||||
)
|
||||
.load()?
|
||||
.is_none()
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn workspace_switch_rejects_a_session_from_a_previous_login() -> anyhow::Result<()> {
|
||||
let server = MockServer::start().await;
|
||||
let (home, manager, mut snapshot) = session(&server).await?;
|
||||
let session_id = manager
|
||||
.auth_cached()
|
||||
.unwrap()
|
||||
.managed_account_session_id()
|
||||
.unwrap();
|
||||
let jwt = token("personal", "user-1", "plus");
|
||||
let tokens = snapshot.tokens.as_mut().unwrap();
|
||||
tokens.login_owner_id = Some("new-login".into());
|
||||
tokens.id_token = parse_chatgpt_jwt_claims(&jwt)?;
|
||||
tokens.access_token = jwt;
|
||||
save_auth(
|
||||
home.path(),
|
||||
&snapshot,
|
||||
AuthCredentialsStoreMode::File,
|
||||
AuthKeyringBackendKind::default(),
|
||||
)?;
|
||||
manager.reload().await;
|
||||
assert_eq!(
|
||||
manager
|
||||
.switch_workspace(&session_id, "business")
|
||||
.await
|
||||
.unwrap_err()
|
||||
.kind(),
|
||||
io::ErrorKind::InvalidInput
|
||||
);
|
||||
assert!(server.received_requests().await.unwrap().is_empty());
|
||||
assert_eq!(
|
||||
manager.auth_cached().unwrap().get_current_auth_json(),
|
||||
Some(snapshot)
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn workspace_sso_only_commits_for_the_requesting_login_and_workspace() -> anyhow::Result<()> {
|
||||
let backend = MockServer::start().await;
|
||||
let (_home, manager, original) = session(&backend).await?;
|
||||
let login = manager.auth_cached().unwrap().workspace_login(
|
||||
"login-1",
|
||||
"team".into(),
|
||||
/*connection*/ None,
|
||||
)?;
|
||||
let result = |workspace: &str, user: &str| -> anyhow::Result<AuthDotJson> {
|
||||
let mut updated = original.clone();
|
||||
let tokens = updated.tokens.as_mut().unwrap();
|
||||
tokens.access_token = token(workspace, user, "business");
|
||||
tokens.id_token = parse_chatgpt_jwt_claims(&tokens.access_token)?;
|
||||
tokens.account_id = Some(workspace.into());
|
||||
tokens.login_owner_id = Some("new-login".into());
|
||||
Ok(updated)
|
||||
};
|
||||
assert!(login.save(result("team", "different-user")?).is_err());
|
||||
assert!(login.save(result("other-workspace", "user-1")?).is_err());
|
||||
assert_eq!(login.storage.load_account_grant()?, Some(original.clone()));
|
||||
login.save(result("team", "user-1")?)?;
|
||||
let selected = login.storage.load_account_grant()?.unwrap().tokens.unwrap();
|
||||
assert_eq!(selected.account_id.as_deref(), Some("team"));
|
||||
assert_eq!(selected.login_owner_id.as_deref(), Some("login-1"));
|
||||
manager.logout().await?;
|
||||
assert!(login.save(result("team", "user-1")?).is_err());
|
||||
assert!(login.storage.load_account_grant()?.is_none());
|
||||
Ok(())
|
||||
}
|
||||
@@ -182,6 +182,31 @@ pub(super) fn auth_storage_commit_guard() -> std::io::Result<std::sync::MutexGua
|
||||
}
|
||||
|
||||
pub(super) trait AuthStorageBackend: Debug + Send + Sync {
|
||||
fn persistent_home(&self) -> Option<&Path> {
|
||||
None
|
||||
}
|
||||
|
||||
/// Serialize the whole read/modify/write across managers and processes.
|
||||
fn lock_for_write(
|
||||
&self,
|
||||
) -> std::io::Result<(std::sync::MutexGuard<'static, ()>, Option<File>)> {
|
||||
let guard = auth_storage_commit_guard()?;
|
||||
let file = if let Some(home) = self.persistent_home() {
|
||||
std::fs::create_dir_all(home)?;
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.write(true)
|
||||
.create(true)
|
||||
.truncate(false)
|
||||
.open(home.join("auth.lock"))?;
|
||||
file.lock()?;
|
||||
Some(file)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
Ok((guard, file))
|
||||
}
|
||||
|
||||
fn load(&self) -> std::io::Result<Option<AuthDotJson>>;
|
||||
/// An unavailable keyring cannot authorize using an older fallback record.
|
||||
fn load_account_grant(&self) -> std::io::Result<Option<AuthDotJson>> {
|
||||
@@ -214,6 +239,10 @@ impl FileAuthStorage {
|
||||
}
|
||||
|
||||
impl AuthStorageBackend for FileAuthStorage {
|
||||
fn persistent_home(&self) -> Option<&Path> {
|
||||
Some(&self.codex_home)
|
||||
}
|
||||
|
||||
fn load(&self) -> std::io::Result<Option<AuthDotJson>> {
|
||||
let auth_file = get_auth_file(&self.codex_home);
|
||||
let auth_dot_json = match self.try_read_auth_json(&auth_file) {
|
||||
@@ -320,6 +349,10 @@ impl DirectKeyringAuthStorage {
|
||||
}
|
||||
|
||||
impl AuthStorageBackend for DirectKeyringAuthStorage {
|
||||
fn persistent_home(&self) -> Option<&Path> {
|
||||
Some(&self.codex_home)
|
||||
}
|
||||
|
||||
fn load(&self) -> std::io::Result<Option<AuthDotJson>> {
|
||||
let key = compute_store_key(&self.codex_home)?;
|
||||
self.load_from_keyring(&key)
|
||||
@@ -398,6 +431,10 @@ impl SecretsKeyringAuthStorage {
|
||||
}
|
||||
|
||||
impl AuthStorageBackend for SecretsKeyringAuthStorage {
|
||||
fn persistent_home(&self) -> Option<&Path> {
|
||||
Some(&self.codex_home)
|
||||
}
|
||||
|
||||
fn load(&self) -> std::io::Result<Option<AuthDotJson>> {
|
||||
match self
|
||||
.secrets_manager
|
||||
@@ -489,6 +526,10 @@ impl AutoAuthStorage {
|
||||
}
|
||||
|
||||
impl AuthStorageBackend for AutoAuthStorage {
|
||||
fn persistent_home(&self) -> Option<&Path> {
|
||||
Some(&self.file_storage.codex_home)
|
||||
}
|
||||
|
||||
fn load_account_grant(&self) -> std::io::Result<Option<AuthDotJson>> {
|
||||
match self.keyring_storage.load()? {
|
||||
Some(auth) => Ok(Some(auth)),
|
||||
|
||||
@@ -71,6 +71,10 @@ impl ObservedStorage {
|
||||
}
|
||||
|
||||
impl AuthStorageBackend for ObservedStorage {
|
||||
fn persistent_home(&self) -> Option<&std::path::Path> {
|
||||
self.inner.persistent_home()
|
||||
}
|
||||
|
||||
fn load(&self) -> std::io::Result<Option<AuthDotJson>> {
|
||||
let mut telemetry = telemetry(self.mode, self.kind, Operation::Load);
|
||||
let result = self.inner.load();
|
||||
|
||||
@@ -27,6 +27,7 @@ use std::time::Duration;
|
||||
|
||||
use crate::auth::AuthDotJson;
|
||||
use crate::auth::AuthKeyringBackendKind;
|
||||
use crate::auth::WorkspaceLogin;
|
||||
use crate::auth::save_auth;
|
||||
use crate::callback_params::LIFE_SCIENCES_OAUTH_STATE_SUFFIX;
|
||||
use crate::callback_params::LoginCallbackResult;
|
||||
@@ -92,6 +93,7 @@ pub struct ServerOptions {
|
||||
pub port: u16,
|
||||
pub open_browser: bool,
|
||||
pub force_state: Option<String>,
|
||||
pub workspace_login: Option<WorkspaceLogin>,
|
||||
pub forced_chatgpt_workspace_id: Option<Vec<String>>,
|
||||
pub codex_streamlined_login: bool,
|
||||
pub login_success_page: LoginSuccessPage,
|
||||
@@ -117,6 +119,7 @@ impl ServerOptions {
|
||||
port: DEFAULT_PORT,
|
||||
open_browser: true,
|
||||
force_state: None,
|
||||
workspace_login: None,
|
||||
forced_chatgpt_workspace_id,
|
||||
codex_streamlined_login: false,
|
||||
login_success_page: LoginSuccessPage::default(),
|
||||
@@ -199,6 +202,7 @@ pub fn run_login_server(opts: ServerOptions) -> io::Result<LoginServer> {
|
||||
&pkce,
|
||||
&state,
|
||||
opts.forced_chatgpt_workspace_id.as_deref(),
|
||||
opts.workspace_login.as_ref(),
|
||||
)?;
|
||||
|
||||
if opts.open_browser {
|
||||
@@ -580,6 +584,7 @@ fn build_authorize_url(
|
||||
pkce: &PkceCodes,
|
||||
state: &str,
|
||||
forced_chatgpt_workspace_ids: Option<&[String]>,
|
||||
workspace_login: Option<&WorkspaceLogin>,
|
||||
) -> io::Result<String> {
|
||||
let originator = originator().value;
|
||||
let workspace_ids = forced_chatgpt_workspace_ids.map(|ids| ids.join(","));
|
||||
@@ -591,6 +596,15 @@ fn build_authorize_url(
|
||||
if let Some(workspace_ids) = workspace_ids.as_deref() {
|
||||
extra_parameters.push(("allowed_workspace_id", workspace_ids));
|
||||
}
|
||||
if let Some(login) = workspace_login {
|
||||
extra_parameters.push(("current_workspace_id", &login.workspace_id));
|
||||
if let Some(email) = &login.email {
|
||||
extra_parameters.push(("login_hint", email));
|
||||
}
|
||||
if let Some(connection) = &login.connection {
|
||||
extra_parameters.push(("connection", connection));
|
||||
}
|
||||
}
|
||||
build_authorization_url(AuthorizationRequest {
|
||||
endpoint: &format!("{issuer}/oauth/authorize"),
|
||||
client_id,
|
||||
@@ -830,6 +844,7 @@ pub(crate) async fn persist_tokens_async(
|
||||
let id_token = exchanged.id_token.clone();
|
||||
let access_token = exchanged.access_token.clone();
|
||||
let refresh_token = exchanged.refresh_token.clone();
|
||||
let workspace_login = opts.workspace_login.clone();
|
||||
let provenance = AccountOAuthProvenance {
|
||||
issuer: opts.issuer.clone(),
|
||||
client_id: opts.client_id.clone(),
|
||||
@@ -864,6 +879,9 @@ pub(crate) async fn persist_tokens_async(
|
||||
bedrock_api_key: None,
|
||||
bedrock_access_keys: None,
|
||||
};
|
||||
if let Some(login) = workspace_login {
|
||||
return login.save(auth);
|
||||
}
|
||||
save_auth(
|
||||
&codex_home,
|
||||
&auth,
|
||||
|
||||
@@ -147,6 +147,7 @@ async fn end_to_end_login_flow_persists_auth_json() -> Result<()> {
|
||||
port: 0,
|
||||
open_browser: false,
|
||||
force_state: Some(state),
|
||||
workspace_login: None,
|
||||
forced_chatgpt_workspace_id: Some(vec![chatgpt_account_id.to_string()]),
|
||||
codex_streamlined_login: false,
|
||||
auth_keyring_backend_kind: AuthKeyringBackendKind::Direct,
|
||||
@@ -258,6 +259,7 @@ async fn hosted_login_redirects_to_configured_open_app_url() -> Result<()> {
|
||||
port: 0,
|
||||
open_browser: false,
|
||||
force_state: Some("streamlined_state".to_string()),
|
||||
workspace_login: None,
|
||||
forced_chatgpt_workspace_id: None,
|
||||
codex_streamlined_login: false,
|
||||
login_success_page: LoginSuccessPage::Hosted {
|
||||
@@ -311,6 +313,7 @@ async fn creates_missing_codex_home_dir() -> Result<()> {
|
||||
port: 0,
|
||||
open_browser: false,
|
||||
force_state: Some(state),
|
||||
workspace_login: None,
|
||||
forced_chatgpt_workspace_id: None,
|
||||
codex_streamlined_login: false,
|
||||
auth_keyring_backend_kind: AuthKeyringBackendKind::Direct,
|
||||
@@ -354,6 +357,7 @@ async fn login_server_includes_forced_workspaces_as_one_query_param() -> Result<
|
||||
port: 0,
|
||||
open_browser: false,
|
||||
force_state: Some(state),
|
||||
workspace_login: None,
|
||||
forced_chatgpt_workspace_id: Some(vec![
|
||||
WORKSPACE_ID_ALLOWED.to_string(),
|
||||
WORKSPACE_ID_SECOND_ALLOWED.to_string(),
|
||||
@@ -398,6 +402,7 @@ async fn forced_chatgpt_workspace_id_mismatch_blocks_login() -> Result<()> {
|
||||
port: 0,
|
||||
open_browser: false,
|
||||
force_state: Some(state.clone()),
|
||||
workspace_login: None,
|
||||
forced_chatgpt_workspace_id: Some(vec![WORKSPACE_ID_ALLOWED.to_string()]),
|
||||
codex_streamlined_login: false,
|
||||
auth_keyring_backend_kind: AuthKeyringBackendKind::Direct,
|
||||
@@ -461,6 +466,7 @@ async fn oauth_access_denied_missing_entitlement_blocks_login_with_clear_error()
|
||||
port: 0,
|
||||
open_browser: false,
|
||||
force_state: Some(state.clone()),
|
||||
workspace_login: None,
|
||||
forced_chatgpt_workspace_id: None,
|
||||
codex_streamlined_login: false,
|
||||
auth_keyring_backend_kind: AuthKeyringBackendKind::Direct,
|
||||
@@ -532,6 +538,7 @@ async fn oauth_access_denied_unknown_reason_uses_generic_error_page() -> Result<
|
||||
port: 0,
|
||||
open_browser: false,
|
||||
force_state: Some(state.clone()),
|
||||
workspace_login: None,
|
||||
forced_chatgpt_workspace_id: None,
|
||||
codex_streamlined_login: false,
|
||||
auth_keyring_backend_kind: AuthKeyringBackendKind::Direct,
|
||||
@@ -682,6 +689,7 @@ async fn cancels_previous_login_server_when_port_is_in_use() -> Result<()> {
|
||||
port: 0,
|
||||
open_browser: false,
|
||||
force_state: Some("cancel_state".to_string()),
|
||||
workspace_login: None,
|
||||
forced_chatgpt_workspace_id: None,
|
||||
codex_streamlined_login: false,
|
||||
auth_keyring_backend_kind: AuthKeyringBackendKind::Direct,
|
||||
@@ -706,6 +714,7 @@ async fn cancels_previous_login_server_when_port_is_in_use() -> Result<()> {
|
||||
port: login_port,
|
||||
open_browser: false,
|
||||
force_state: Some("cancel_state_2".to_string()),
|
||||
workspace_login: None,
|
||||
forced_chatgpt_workspace_id: None,
|
||||
codex_streamlined_login: false,
|
||||
auth_keyring_backend_kind: AuthKeyringBackendKind::Direct,
|
||||
|
||||
Reference in New Issue
Block a user