Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(codex): 隔离 Cindy AI 和自定义 API 任务对订阅 OAuth 的依赖 (#5091)

fmfsaisaid4489b81a34c
diff --git a/apps/desktop/src/main/__tests__/sessionRuntimeControlWiring.test.ts b/apps/desktop/src/main/__tests__/sessionRuntimeControlWiring.test.ts
index 7df1f30ea4..a0a2e11843 100644
--- a/apps/desktop/src/main/__tests__/sessionRuntimeControlWiring.test.ts
+++ b/apps/desktop/src/main/__tests__/sessionRuntimeControlWiring.test.ts
@@ -758,14 +758,15 @@ describe('session runtime control wiring', () => {
);
});
- it('resumes native Codex history across credentials and reserves window rebuilding for send', () => {
- const body = handlerBody(
- registerSource,
- 'const handleSetModel = async (',
- 'const recoverRemoteRuntimeAxisPersistence',
- );
- expect(body).not.toContain('forkSdkSession(');
- expect(body).not.toContain('relinkCodexProviderThread(');
+ it('only relinks retained cross-host writers without rewriting native history', () => {
+ const body = handlerBody(registerSource, 'const handleSetModel = async (', 'const recoverRemoteRuntimeAxisPersistence');
+ expect(body).toContain('requiresCodexThreadRelink: () => maker.requiresCodexThreadHostTransfer(');
+ expect(body).toContain('...(canTransferThread ? {');
+ expect(body).toContain('relinkCodexProviderThread(');
+ expect(body).toContain('stripEncryptedReasoning: false');
+ expect(body).toContain('commitCodexThreadTransfer(transferDb!.client, sourceSnapshot');
+ expect(body).toMatch(/if \(result\.persistedRoute === true && isDeviceLinkInvoke\(\)\) \{\s*markRemoteSettingPersistedInsideHandler\(response\);/);
+ expect(body).toContain('getCurrentDbClientSnapshot()?.clientEpoch !== transferDb.clientEpoch');
expect(body).not.toContain('prepareNativeSessionRecovery(');
expect(body).toContain('codexAuthInjection: getCodexProxyAuthInjectionState()');
expect(body).toContain('confirmedTargetPressure:');
@@ -899,7 +900,7 @@ describe('session runtime control wiring', () => {
const retainedRecovery = handlerBody(
setModel,
'const reconcileRetainedLiveProfile = async (): Promise<void> => {',
- 'try {\n const result = routeExplicit',
+ 'const transferDb = getCurrentDbClientSnapshot();',
);
const capabilityLookup = retainedRecovery.indexOf(
'const retainedProviders = await getDesktopProviderService().listProviders({',
diff --git a/apps/desktop/src/main/maker-host/__tests__/codexAuthInvalidation.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexAuthInvalidation.test.ts
index 298dfd8d02..93a4e59cdc 100644
--- a/apps/desktop/src/main/maker-host/__tests__/codexAuthInvalidation.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/codexAuthInvalidation.test.ts
@@ -1,4 +1,6 @@
import fs from 'node:fs';
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
import os from 'node:os';
import path from 'node:path';
import { afterEach, describe, expect, it, vi } from 'vitest';
@@ -2789,3 +2791,255 @@ describe('local Codex account display identity', () => {
expect(JSON.stringify(result)).not.toContain('signature');
});
});
+
+describe('deferred Codex OAuth dispatch proof', () => {
+ it('matches the real HTTP reader account contract without widening workspace identity', async () => {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-http-account-proof-'));
+ dirs.push(root);
+ h.userDataDir = path.join(root, 'data');
+ h.dataOwnerId = 'http-reader-owner';
+ vi.spyOn(os, 'homedir').mockReturnValue(path.join(root, 'home'));
+ const home = path.join(h.userDataDir, 'codex-home');
+ fs.mkdirSync(home, { recursive: true });
+ const authPath = path.join(home, 'auth.json');
+ const accessToken = idToken({ exp: Math.floor(Date.now() / 1000) + 3600, sub: 'same-user' });
+ const workspaceToken = (workspace: string) => idToken({
+ sub: 'same-user', 'https://api.openai.com/auth': { chatgpt_account_id: workspace },
+ });
+ const write = (tokens: { account_id?: string; id_token?: string }) => {
+ const raw = JSON.stringify({ tokens: { access_token: accessToken, ...tokens } });
+ fs.writeFileSync(authPath, raw);
+ return raw;
+ };
+ const { bindNativeProviderAuth } = await import('../nativeProviderAuthBinding.js');
+ const { desktopCodexAuthAdapter: adapter } = await import('../auth-adapters.js');
+ const reader = await import('../anthropic-responses-bridge-host.js');
+ const proxy = await import('../codex-proxy-host.js');
+ proxy.setCodexSubagentOAuthReader(reader.getChatgptBridgeAuthForDispatch);
+ proxy.registerComposed('http-parent', 'http-parent-thread', 'fixture', {
+ subagentRoute: { providerId: 'openai', catalogModel: 'gpt-5.4', reasoningEffort: 'high' },
+ });
+ const transform = proxy.createModelRoutingTransform('env-key', []);
+ const context = { reqId: 1, method: 'POST', url: '/responses', headers: {
+ 'thread-id': 'http-child', 'x-openai-subagent': 'collab_spawn',
+ 'x-codex-parent-thread-id': 'http-parent-thread',
+ } };
+ try {
+ for (const { tokens, header, workspace } of [
+ { tokens: { account_id: 'explicit', id_token: workspaceToken('other') }, header: 'explicit', workspace: 'explicit' },
+ { tokens: { id_token: workspaceToken('workspace-a') }, header: 'workspace-a', workspace: 'workspace-a' },
+ { tokens: { id_token: idToken({ sub: 'same-user' }) }, header: 'same-user', workspace: null },
+ { tokens: { id_token: idToken({}) }, header: null, workspace: null },
+ { tokens: {}, header: null, workspace: null },
+ ]) {
+ const raw = write(tokens);
+ bindNativeProviderAuth('openai', { instanceIsolated: true });
+ reader.clearChatgptBridgeCredentialCache();
+ expect((await reader.getChatgptBridgeAuth()).accountId).toBe(header);
+ await expect(adapter.getAccountId()).resolves.toBe(workspace);
+ const auth = await reader.getChatgptBridgeAuthForDispatch();
+ expect(auth.accountId).toBe(header);
+ expect(auth.canDispatch()).toBe(true);
+ const decision = await transform({ model: 'gpt-5.4' }, context);
+ expect(decision?.headerOverride?.authorization).toBe(`Bearer ${accessToken}`);
+ expect(decision?.headerOverride?.['chatgpt-account-id'] ?? null).toBe(header);
+ if (header === null) expect(decision?.headerDelete).toContain('chatgpt-account-id');
+ expect(decision?.dispatchGenerationValid?.()).toBe(true);
+ expect(fs.readFileSync(authPath, 'utf8')).toBe(raw);
+ }
+
+ // Same subject AND access token: only the workspace changes. Do not clear
+ // the reader cache; the stale HTTP identity must fail proof and be reread.
+ write({ id_token: workspaceToken('workspace-a') });
+ const a = await reader.getChatgptBridgeAuthForDispatch();
+ const oldDecision = await transform({ model: 'gpt-5.4' }, context);
+ write({ id_token: workspaceToken('workspace-b') });
+ expect(a.canDispatch()).toBe(false);
+ expect(oldDecision?.dispatchGenerationValid?.()).toBe(false);
+ const b = await reader.getChatgptBridgeAuthForDispatch();
+ expect(b.accountId).toBe('workspace-b');
+ expect(b.canDispatch()).toBe(true);
+ const nextDecision = await transform({ model: 'gpt-5.4' }, context);
+ expect(nextDecision?.headerOverride?.['chatgpt-account-id']).toBe('workspace-b');
+ expect(nextDecision?.dispatchGenerationValid?.()).toBe(true);
+ proxy.unregister('http-parent');
+ expect(nextDecision?.dispatchGenerationValid?.()).toBe(false);
+ } finally {
+ proxy.unregister('http-parent');
+ reader.clearChatgptBridgeCredentialCache();
+ }
+ });
+
+ it('binds an independent account child to its real credential and authorization record', async () => {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-codex-multi-reader-'));
+ dirs.push(root);
+ h.userDataDir = path.join(root, 'data');
+ h.dataOwnerId = 'reader-owner';
+ vi.spyOn(os, 'homedir').mockReturnValue(path.join(root, 'home'));
+ const { buildUserProvider } = await import('@cindy/model-providers');
+ const catalog = await import('../active-catalog.js');
+ catalog.setCustomProviders([buildUserProvider({
+ id: 'openai-child', name: 'Synthetic child account', auth: { method: 'oauth', native: 'codex' },
+ runtimes: { codex: { baseUrl: 'https://chatgpt.com/backend-api/codex', models: [{ id: 'gpt-5.4', name: 'Fixture' }] } },
+ })]);
+ const accounts = await import('../codex-account-auth.js');
+ const home = accounts.codexAccountHome('openai-child');
+ fs.mkdirSync(home, { recursive: true });
+ const expiry = Math.floor(Date.now() / 1000) + 3600;
+ const write = (account: string) => {
+ const raw = JSON.stringify({ tokens: { access_token: idToken({ exp: expiry, sub: account }), account_id: account } });
+ fs.writeFileSync(path.join(home, 'auth.json'), raw);
+ fs.writeFileSync(path.join(home, 'account.json'), JSON.stringify(accounts.parseCodexAccountIdentity(raw)));
+ };
+ const reader = await import('../anthropic-responses-bridge-host.js');
+ const proxy = await import('../codex-proxy-host.js');
+ const routes = await import('../provider-route.js');
+ write('synthetic-a');
+ proxy.setCodexSubagentOAuthReader(reader.getChatgptBridgeAuthForDispatch);
+ proxy.registerComposed('multi-parent', 'multi-parent-thread', 'fixture', {
+ subagentRoute: { providerId: 'openai-child', catalogModel: 'gpt-5.4', reasoningEffort: 'high' },
+ });
+ const transform = proxy.createModelRoutingTransform('env-key', []);
+ const context = { reqId: 1, method: 'POST', url: '/responses', headers: {
+ 'thread-id': 'multi-child', 'x-openai-subagent': 'collab_spawn', 'x-codex-parent-thread-id': 'multi-parent-thread',
+ } };
+ try {
+ const first = await transform({ model: 'gpt-5.4' }, context);
+ expect(first?.headerOverride?.['chatgpt-account-id']).toBe('synthetic-a');
+ expect(first?.dispatchGenerationValid?.()).toBe(true);
+ write('synthetic-b');
+ expect(first?.dispatchGenerationValid?.()).toBe(false);
+ const next = await transform({ model: 'gpt-5.4' }, context);
+ expect(next?.headerOverride?.['chatgpt-account-id']).toBe('synthetic-b');
+ expect(next?.dispatchGenerationValid?.()).toBe(true);
+ const finish = routes.beginProviderRouteMutation('openai-child');
+ expect(next?.dispatchGenerationValid?.()).toBe(false);
+ finish.commit(); finish();
+ expect(next?.dispatchGenerationValid?.()).toBe(false);
+ const current = await reader.getChatgptBridgeAuthForDispatch('openai-child');
+ await accounts.invalidateCodexAccount('openai-child', 'synthetic-invalidated', current.accessToken);
+ expect(current.canDispatch()).toBe(false);
+ await expect(reader.getChatgptBridgeAuthForDispatch('openai-child')).rejects.toThrow();
+ } finally {
+ proxy.unregister('multi-parent');
+ catalog.setCustomProviders([]);
+ }
+ });
+
+ it('reads and freezes the real bridge credential across same-owner account replacement', async () => {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-codex-reader-proof-'));
+ dirs.push(root);
+ h.userDataDir = path.join(root, 'data');
+ h.dataOwnerId = 'reader-owner';
+ vi.spyOn(os, 'homedir').mockReturnValue(path.join(root, 'home'));
+ const codexHome = path.join(h.userDataDir, 'codex-home');
+ fs.mkdirSync(codexHome, { recursive: true });
+ const fixtureExpiry = Math.floor(Date.now() / 1000) + 3600;
+ const token = (account: string) => idToken({ exp: fixtureExpiry, sub: account });
+ const write = (account: string) => fs.writeFileSync(path.join(codexHome, 'auth.json'), JSON.stringify({ tokens: { access_token: token(account), account_id: account } }));
+ const { bindNativeProviderAuth } = await import('../nativeProviderAuthBinding.js');
+ write('account-a');
+ bindNativeProviderAuth('openai', { instanceIsolated: true });
+ const reader = await import('../anthropic-responses-bridge-host.js');
+ reader.clearChatgptBridgeCredentialCache();
+ const a = await reader.getChatgptBridgeAuthForDispatch();
+ expect(a.accountId).toBe('account-a');
+ expect(a.canDispatch()).toBe(true);
+ const proxy = await import('../codex-proxy-host.js');
+ proxy.setCodexSubagentOAuthReader(reader.getChatgptBridgeAuthForDispatch);
+ proxy.registerComposed('reader-parent', 'reader-parent-thread', 'fixture', {
+ subagentRoute: { providerId: 'openai', catalogModel: 'gpt-5.4', reasoningEffort: 'high' },
+ });
+ const transform = proxy.createModelRoutingTransform('provider-oauth', []);
+ const ctx = { reqId: 1, method: 'POST', url: '/responses', headers: {
+ 'thread-id': 'reader-child', 'x-openai-subagent': 'collab_spawn', 'x-codex-parent-thread-id': 'reader-parent-thread',
+ } };
+ const oldDecision = await transform({ model: 'gpt-5.4' }, ctx);
+ expect(oldDecision?.headerOverride).toMatchObject({ 'chatgpt-account-id': 'account-a' });
+ expect(oldDecision?.dispatchGenerationValid?.()).toBe(true);
+ write('account-b');
+ bindNativeProviderAuth('openai', { instanceIsolated: true });
+ expect(a.canDispatch()).toBe(false);
+ expect(oldDecision?.dispatchGenerationValid?.()).toBe(false);
+ const nextDecision = await transform({ model: 'gpt-5.4' }, ctx);
+ expect(nextDecision?.headerOverride).toMatchObject({ 'chatgpt-account-id': 'account-b' });
+ const b = await reader.getChatgptBridgeAuthForDispatch();
+ expect(b.accountId).toBe('account-b');
+ expect(b.accessToken).toBe(token('account-b'));
+ expect(b.canDispatch()).toBe(true);
+ const { desktopCodexAuthAdapter } = await import('../auth-adapters.js');
+ const { createAnthropicCompatProxy, createEncryptedContentRecoveryRule } = await import('@cindy/anthropic-compat-proxy');
+ let childRequests = 0;
+ const upstream = createServer(async (req, res) => {
+ let body = '';
+ for await (const chunk of req) body += chunk;
+ if (JSON.parse(body).model === 'api-parent') {
+ res.writeHead(200, { 'content-type': 'application/json' }).end('{}');
+ return;
+ }
+ childRequests++;
+ await desktopCodexAuthAdapter.invalidate('token_revoked', { credentialAttribution: 'unproven' });
+ res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: {
+ message: 'Encrypted content gAAA... could not be decrypted or parsed.', code: 'invalid_encrypted_content',
+ } }));
+ });
+ await new Promise<void>((resolve) => upstream.listen(0, '127.0.0.1', resolve));
+ const endpoint = `http://127.0.0.1:${(upstream.address() as AddressInfo).port}`;
+ const forwarding = await createAnthropicCompatProxy({
+ upstream: endpoint, transformRequest: [],
+ routingTransform: (body) => (body as { model?: string }).model === 'api-parent'
+ ? null : { ...nextDecision, upstreamOverride: endpoint },
+ recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
+ });
+ try {
+ const send = (model: string) => fetch(`${forwarding.url}/responses`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ model, input: [{ type: 'reasoning', encrypted_content: 'gAAA-fixture' }] }) });
+ const rejected = await send('gpt-5.4');
+ expect(rejected.status).toBe(503);
+ await rejected.text();
+ expect(childRequests).toBe(1);
+ const parent = await send('api-parent');
+ expect(parent.status).toBe(200);
+ await parent.text();
+ } finally {
+ await forwarding.dispose();
+ await new Promise<void>((resolve) => upstream.close(() => resolve()));
+ }
+ expect(b.canDispatch()).toBe(false);
+ expect(nextDecision?.dispatchGenerationValid?.()).toBe(false);
+ proxy.unregister('reader-parent');
+ await expect(reader.getChatgptBridgeAuthForDispatch()).rejects.toThrow();
+ reader.clearChatgptBridgeCredentialCache();
+ });
+
+ it('rejects same-owner account replacement and logout/relogin without reviving an old decision', async () => {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-codex-dispatch-proof-'));
+ dirs.push(root);
+ h.userDataDir = path.join(root, 'data');
+ h.dataOwnerId = 'same-owner';
+ vi.spyOn(os, 'homedir').mockReturnValue(path.join(root, 'home'));
+ const codexHome = path.join(h.userDataDir, 'codex-home');
+ fs.mkdirSync(codexHome, { recursive: true });
+ const authPath = path.join(codexHome, 'auth.json');
+ const write = (token: string, account: string) => fs.writeFileSync(authPath, JSON.stringify({ tokens: { access_token: token, account_id: account } }));
+ const { bindNativeProviderAuth, unbindNativeProviderAuth } = await import('../nativeProviderAuthBinding.js');
+ const { DesktopCodexAuthAdapter } = await import('../auth-adapters.js');
+ write('synthetic-a', 'account-a');
+ bindNativeProviderAuth('openai', { instanceIsolated: true });
+ const adapter = new DesktopCodexAuthAdapter();
+ const a = adapter.captureOAuthDispatchProof('synthetic-a', 'account-a');
+ expect(a?.()).toBe(true);
+ write('synthetic-b', 'account-b');
+ bindNativeProviderAuth('openai', { instanceIsolated: true });
+ expect(a?.()).toBe(false);
+ expect(adapter.captureOAuthDispatchProof('synthetic-a', 'account-a')).toBeNull();
+ const b = adapter.captureOAuthDispatchProof('synthetic-b', 'account-b');
+ expect(b?.()).toBe(true);
+ unbindNativeProviderAuth('openai');
+ expect(b?.()).toBe(false);
+ bindNativeProviderAuth('openai', { instanceIsolated: true });
+ expect(b?.()).toBe(false);
+ expect(adapter.captureOAuthDispatchProof('synthetic-b', 'account-b')?.()).toBe(true);
+ await adapter.invalidate('token_revoked', { credentialAttribution: 'unproven' });
+ expect(adapter.captureOAuthDispatchProof('synthetic-b', 'account-b')).toBeNull();
+ });
+});
diff --git a/apps/desktop/src/main/maker-host/__tests__/codexCredentialSwitch.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexCredentialSwitch.test.ts
index c9fd60b9cd..eb43dba565 100644
--- a/apps/desktop/src/main/maker-host/__tests__/codexCredentialSwitch.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/codexCredentialSwitch.test.ts
@@ -739,3 +739,23 @@ describe('prepareLocalCodexCredentialModeSwitch', () => {
})).rejects.toThrow(/\(oauth-bearer\(registered: fallback\) -> gateway-key\).*busy-codex-1/);
});
});
+
+
+describe('Codex host-scoped credential coordination', () => {
+ it.each(['local', 'local:external-auth'])('does not block or close a busy sibling when replacing %s', async (hostKey) => {
+ const sibling = hostKey === 'local' ? 'local:external-auth' : 'local';
+ const closeSession = vi.fn(async () => undefined);
+ const result = await prepareLocalCodexCredentialModeSwitch({
+ hostKey,
+ maker: {
+ listActiveSessions: () => [
+ { id: 'target', agentKind: 'codex', codexHostKey: hostKey, isTurnRunning: () => false },
+ { id: 'sibling', agentKind: 'codex', codexHostKey: sibling, isTurnRunning: () => true },
+ ],
+ closeSession,
+ },
+ });
+ expect(result.closedSessionIds).toEqual(['target']);
+ expect(closeSession).toHaveBeenCalledExactlyOnceWith('target', 'runtime-refresh');
+ });
+});
diff --git a/apps/desktop/src/main/maker-host/__tests__/codexCustomProviderRoute.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexCustomProviderRoute.test.ts
index 547fc1b755..124297ff0c 100644
--- a/apps/desktop/src/main/maker-host/__tests__/codexCustomProviderRoute.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/codexCustomProviderRoute.test.ts
@@ -16,6 +16,7 @@ import {
isCodexCustomProviderNamespacePath,
parseCodexCustomProviderPath,
relativeProviderRequestPath,
+ registerCodexScopedCustomProviderRoutes,
resolveCodexCustomProviderModelProviderId,
setCodexAppliedCustomProviderRoutes,
toCodexCustomProviderHostRoutes,
@@ -371,3 +372,23 @@ describe('Codex custom Provider identity', () => {
expect(relativeProviderRequestPath('https://provider.example/v1', '//evil')).toBeNull();
});
});
+
+
+describe('scoped Host capabilities', () => {
+ it('keeps capability snapshots until their own Host retires', () => {
+ const routes = deriveCodexCustomProviderRoutes(catalog());
+ const releaseOld = registerCodexScopedCustomProviderRoutes('external:1', routes);
+ const releaseNew = registerCodexScopedCustomProviderRoutes('external:2', routes);
+ try {
+ setCodexAppliedCustomProviderRoutes([]);
+ expect(hasCodexAppliedCustomProviderCapability('provider-alpha', 'imageGeneration')).toBe(true);
+ releaseOld();
+ expect(hasCodexAppliedCustomProviderCapability('provider-alpha', 'imageGeneration')).toBe(true);
+ releaseNew();
+ expect(hasCodexAppliedCustomProviderCapability('provider-alpha', 'imageGeneration')).toBe(false);
+ } finally {
+ releaseOld();
+ releaseNew();
+ }
+ });
+});
diff --git a/apps/desktop/src/main/maker-host/__tests__/codexGatewayAuth.integration.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexGatewayAuth.integration.test.ts
new file mode 100644
index 0000000000..63e510fd61
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/__tests__/codexGatewayAuth.integration.test.ts
@@ -0,0 +1,221 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { describe, expect, it, vi } from 'vitest';
+import { buildUserProvider } from '@cindy/model-providers';
+import { CodexAgent } from '../../../../../../packages/maker-core/src/agents/codex/index.js';
+import { AppServerHost } from '../../../../../../packages/maker-core/src/agents/codex/app-server/host.js';
+import type { AgentSessionHandle } from '../../../../../../packages/maker-core/src/agents/base-agent.js';
+import type { Logger } from '../../../../../../packages/maker-core/src/interfaces/logger.js';
+
+const fixture = vi.hoisted(() => ({ userData: '', home: '', gatewayKey: 'synthetic-gateway-key' }));
+vi.mock('electron', () => ({ app: {
+ isPackaged: true,
+ getPath: (name: string) => name === 'home' ? fixture.home : fixture.userData,
+ getAppPath: () => fixture.userData,
+}, safeStorage: { isEncryptionAvailable: () => false } }));
+vi.mock('../../appCapabilities.js', () => ({ getAppCapabilities: () => ({ canUseCindyGateway: true }) }));
+vi.mock('../../secrets/providerSecretStore.js', () => ({ getProviderSecretStore: () => ({ get: () => fixture.gatewayKey }) }));
+vi.mock('../../appSessionState.js', async (original) => ({
+ ...await original<typeof import('../../appSessionState.js')>(),
+ getActiveAppSession: () => ({ mode: 'cloud', dataOwnerId: 'synthetic-owner', generation: 1 }),
+ activeOwnerScopeKey: () => 'cloud:synthetic-owner:1',
+ isAppSessionBoundaryPending: () => false,
+}));
+
+const binary = process.env.CINDY_TEST_CODEX_BINARY;
+const logger: Logger = { trace() {}, debug() {}, info() {}, warn() {}, error() {}, fatal() {}, child: () => logger };
+
+describe.skipIf(!binary)('first-profile gateway/API startup with native Codex', () => {
+ it.each(['none', 'fresh-revoked', 'expired-refreshable', 'expired-revoked', 'healthy-concurrent', 'revoked-concurrent', 'gated-concurrent'].flatMap((auth) =>
+ ['xd', 'cprov-key'].flatMap((providerId) => (auth.endsWith('-concurrent') ? [false, true] : [false])
+ .flatMap((seeded) => (auth === 'gated-concurrent' ? [false, true] : [true])
+ .flatMap(officialFirst => (auth === 'gated-concurrent' && !seeded ? [false, true] : [false])
+ .map(separateDb => ({ auth, providerId, seeded, officialFirst, separateDb }))))),
+ ))('$providerId independent of $auth (seeded=$seeded officialFirst=$officialFirst separateDb=$separateDb)', async ({ auth, providerId, seeded, officialFirst, separateDb }) => {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-gateway-native-'));
+ fixture.home = path.join(root, 'home');
+ fixture.userData = path.join(root, 'profile');
+ fixture.gatewayKey = providerId === 'xd' ? 'synthetic-gateway-key' : '';
+ fs.mkdirSync(path.join(fixture.home, '.codex'), { recursive: true });
+ fs.mkdirSync(fixture.userData, { recursive: true });
+ const homeSpy = vi.spyOn(os, 'homedir').mockReturnValue(fixture.home);
+ const calls: string[] = [];
+ let rejectApi = false;
+ let officialAccessToken = '';
+ const concurrent = auth.endsWith('-concurrent');
+ let releaseOAuth!: () => void;
+ const oauthGate = new Promise<void>(resolve => { releaseOAuth = resolve; });
+ let refreshEntered!: () => void;
+ const refreshRequested = new Promise<void>(resolve => { refreshEntered = resolve; });
+ let sequence = 0;
+ const server = createServer(async (req, res) => {
+ for await (const chunk of req) void chunk;
+ calls.push(`${req.method} ${req.url}`);
+ if (auth === 'gated-concurrent' && req.url === '/oauth/token') {
+ refreshEntered();
+ await oauthGate;
+ }
+ if (auth === 'healthy-concurrent' && req.url?.startsWith('/models')) {
+ res.writeHead(200, { 'content-type': 'application/json' }).end('{"models":[]}');
+ return;
+ }
+ if (req.url?.endsWith('/responses')) {
+ expect([`Bearer ${providerId === 'xd' ? fixture.gatewayKey : 'synthetic-custom-key'}`, ...(concurrent ? [`Bearer ${officialAccessToken}`] : [])]).toContain(req.headers.authorization);
+ if (rejectApi && req.headers.authorization !== `Bearer ${officialAccessToken}`) {
+ res.writeHead(401, { 'content-type': 'application/json' }).end('{"error":{"message":"synthetic API rejection"}}');
+ return;
+ }
+ const id = `fixture-${++sequence}`;
+ const events = [
+ { type: 'response.created', response: { id } },
+ { type: 'response.output_item.done', item: { type: 'message', role: 'assistant', id: `msg-${id}`, content: [{ type: 'output_text', text: 'synthetic complete' }] } },
+ { type: 'response.completed', response: { id, usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } } },
+ ];
+ res.writeHead(200, { 'content-type': 'text/event-stream', connection: 'close' });
+ res.end(events.map((event) => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`).join(''));
+ return;
+ }
+ if (req.url === '/oauth/token' && auth === 'expired-refreshable') {
+ res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ access_token: 'synthetic-refreshed', refresh_token: 'synthetic-refresh' }));
+ return;
+ }
+ if (auth === 'healthy-concurrent') {
+ res.writeHead(404, { 'content-type': 'application/json' }).end('{"error":{"message":"No optional MCP endpoint in fixture"}}');
+ return;
+ }
+ res.writeHead(401, { 'content-type': 'application/json' }).end('{"error":{"code":"refresh_token_invalidated","message":"synthetic revoked token"}}');
+ });
+ await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+ const endpoint = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+ const systemAuth = path.join(fixture.home, '.codex', 'auth.json');
+ let originalAuth: string | undefined;
+ if (auth !== 'none') {
+ const claims = { sub: 'synthetic-user', exp: Math.floor(Date.now() / 1000) + (auth.startsWith('expired') ? -3600 : 3600), 'https://api.openai.com/auth': { chatgpt_plan_type: auth === 'healthy-concurrent' ? 'plus' : 'business', chatgpt_account_id: 'synthetic-account' } };
+ const token = `eyJhbGciOiJub25lIn0.${Buffer.from(JSON.stringify(claims)).toString('base64url')}.synthetic`;
+ officialAccessToken = token;
+ originalAuth = JSON.stringify({ auth_mode: 'chatgpt', tokens: { access_token: token, id_token: token, refresh_token: 'synthetic-invalid-refresh', account_id: 'synthetic-account' }, last_refresh: new Date(auth.startsWith('expired') ? 0 : Date.now()).toISOString() });
+ fs.writeFileSync(systemAuth, originalAuth, { mode: 0o600 });
+ }
+ const { DesktopCodexAuthAdapter, getCodexHome } = await import('../auth-adapters.js');
+ const { captureCodexLocalAuthPolicy } = await import('../provider-route.js');
+ const { setCustomProviders } = await import('../active-catalog.js');
+ const { buildCodexProxySpawnArgs } = await import('../codex-gateway-config.js');
+ const diagnostics: unknown[] = [];
+ const nativePids: number[] = [];
+ const testLogger: Logger = { ...logger, debug: (...args) => { diagnostics.push(args); }, warn: (...args) => { diagnostics.push(args); }, error: (...args) => { diagnostics.push(args); }, child: () => testLogger };
+ const adapter = new DesktopCodexAuthAdapter();
+ const taskRpcs: string[] = [];
+ const originalRequest = AppServerHost.prototype.request;
+ const rpcSpy = vi.spyOn(AppServerHost.prototype, 'request').mockImplementation(function (this: AppServerHost, method, params, options) {
+ if (['thread/start', 'thread/resume', 'thread/fork'].includes(method)) taskRpcs.push(method);
+ return originalRequest.call(this, method, params, options);
+ });
+ let authEnvSpy: { mockRestore(): void } | undefined;
+ let agent: CodexAgent | undefined;
+ try {
+ // This is the production first-profile reconcile, not an auth-state stub.
+ const detected = await adapter.getState();
+ if (originalAuth) expect(detected).toMatchObject({ authenticated: true, authSource: 'oauth' });
+ const codexHome = getCodexHome();
+ fs.mkdirSync(codexHome, { recursive: true });
+ if (originalAuth) expect(fs.readFileSync(path.join(codexHome, 'auth.json'), 'utf8')).toBe(originalAuth);
+ fs.writeFileSync(path.join(codexHome, 'config.toml'), `chatgpt_base_url="${endpoint}"\ncheck_for_update_on_startup=false\n[analytics]\nenabled=false\n[mcp_servers.cindy_memory]\ncommand="/usr/bin/false"\nenabled=false\n`);
+ if (separateDb) {
+ const officialHome = path.join(root, 'official-native-home');
+ fs.mkdirSync(officialHome);
+ fs.writeFileSync(path.join(officialHome, 'auth.json'), originalAuth!);
+ fs.copyFileSync(path.join(codexHome, 'config.toml'), path.join(officialHome, 'config.toml'));
+ const getEnv = adapter.getAuthEnv.bind(adapter);
+ authEnvSpy = vi.spyOn(adapter, 'getAuthEnv').mockImplementation(async opts => {
+ const env = await getEnv(opts);
+ return opts?.credentialMode === 'oauth-bearer' ? { ...env, CODEX_HOME: officialHome } : env;
+ });
+ }
+ setCustomProviders([buildUserProvider({ id: 'cprov-key', name: 'Synthetic', runtimes: { codex: { baseUrl: endpoint, wireProtocol: 'openai-responses', models: [{ id: 'fixture-model', name: 'Fixture' }] } } })]);
+ const modes: string[] = [];
+ agent = new CodexAgent({
+ binaryPath: binary!, auth: adapter, logger: testLogger,
+ registerLocalCodexAppServerProcess: ({ pid }) => { nativePids.push(pid); },
+ isolateCodexAccountSessions: true,
+ resolveCodexLocalAuthPolicy: captureCodexLocalAuthPolicy,
+ runtimeConfig: { behaviorFlags: { HOME: fixture.home, TMPDIR: root, CODEX_REFRESH_TOKEN_URL_OVERRIDE: `${endpoint}/oauth/token`, HTTP_PROXY: endpoint, HTTPS_PROXY: endpoint, ALL_PROXY: endpoint, NO_PROXY: '127.0.0.1,localhost' } },
+ prepareCodexExtraSpawnConfig: async (_providers, ctx) => {
+ modes.push(ctx.credentialMode ?? 'fallback');
+ if (ctx.credentialMode !== 'oauth-bearer') expect(ctx.localAuthPolicy).toBe('isolated');
+ return { extraArgs: buildCodexProxySpawnArgs(endpoint, ctx.credentialMode === 'oauth-bearer' ? 'oauth-bearer' : ctx.credentialMode === 'gateway-key' ? 'env-key' : 'provider-oauth'), extraEnv: { ...(providerId !== 'xd' ? { XDT_CODEX_API_KEY: 'synthetic-custom-key' } : {}) }, codexProxyActive: true };
+ },
+ });
+ const send = async (handle: AgentSessionHandle, fail = false) => {
+ const events = (async () => {
+ for await (const event of handle.events()) {
+ if (event.type === 'error') { if (fail) return 'error'; throw new Error('unexpected synthetic turn failure'); }
+ if (event.type === 'done') return 'done';
+ }
+ })();
+ await handle.send({ type: 'user', content: 'return synthetic complete' }, { throwOnStartFailure: true });
+ expect(await events).toBe(fail ? 'error' : 'done');
+ };
+ const options = { sessionId: 'same-task', providerId, model: 'fixture-model', workingDir: root };
+ if (seeded) {
+ // Exercise concurrent hosts against an existing native history database.
+ // The paired unseeded case covers truly empty-database startup.
+ const seed = await agent.startSession({ ...options, sessionId: 'initial-native-profile' });
+ await seed.close();
+ }
+ const startOfficial = () => agent!.startSession({ ...options, sessionId: 'official-task', providerId: 'openai' }).then((handle) => ({ handle }), (error: unknown) => ({ error }));
+ const firstOfficial = concurrent && officialFirst ? startOfficial() : undefined;
+ const parentStart = agent.startSession(options);
+ const officialStart = concurrent
+ ? firstOfficial ?? startOfficial()
+ : undefined;
+ if (auth === 'gated-concurrent') await refreshRequested;
+ const handle = await parentStart;
+ const official = auth === 'gated-concurrent' ? undefined : await officialStart;
+ if (auth === 'healthy-concurrent') expect(official).toHaveProperty('handle');
+ if (auth === 'revoked-concurrent') expect(official).toHaveProperty('error');
+ const oauthCalls = calls.filter((call) => call.includes('/oauth/token') || call.includes('/config/bundle'));
+ if (official && 'handle' in official) await send(official.handle);
+ await send(handle); await send(handle);
+ const threadId = handle.id;
+ await handle.close();
+ const resumed = await agent.startSession({ ...options, resumeSessionId: threadId });
+ expect(resumed.id).toBe(threadId);
+ await send(resumed);
+ rejectApi = true;
+ await send(resumed, true);
+ await resumed.close();
+ if (official && 'handle' in official) { await send(official.handle); await official.handle.close(); }
+ expect(modes.filter(mode => mode !== 'oauth-bearer').every((mode) => mode === (providerId === 'xd' ? 'gateway-key' : 'provider-oauth'))).toBe(true);
+ expect(calls.filter((call) => call.includes('/oauth/token') || call.includes('/config/bundle'))).toEqual(oauthCalls);
+ if (auth === 'gated-concurrent') {
+ // All parent startup, turns, resume and API-401 handling completed while
+ // the official refresh response was withheld, not after its timeout.
+ expect(calls.filter(call => call === 'POST /oauth/token')).toHaveLength(1);
+ releaseOAuth();
+ expect(await officialStart).toHaveProperty('error');
+ }
+ if (!concurrent) expect(oauthCalls).toEqual([]);
+ if (auth === 'revoked-concurrent') expect(oauthCalls.length).toBeGreaterThan(0);
+ if (originalAuth) expect(fs.readFileSync(systemAuth, 'utf8')).toBe(originalAuth);
+ expect(taskRpcs.filter(method => method === 'thread/start')).toHaveLength(1 + Number(concurrent) + Number(seeded));
+ expect(taskRpcs.filter(method => method === 'thread/resume')).toHaveLength(1);
+ expect(taskRpcs).not.toContain('thread/fork');
+ expect(nativePids.length).toBeLessThanOrEqual(3 * (2 + Number(concurrent) + Number(seeded)));
+ } catch (error) {
+ throw new Error(`${String(error)}\n${JSON.stringify(diagnostics)}`, { cause: error });
+ } finally {
+ releaseOAuth();
+ await agent?.dispose();
+ rpcSpy.mockRestore();
+ authEnvSpy?.mockRestore();
+ setCustomProviders([]);
+ await new Promise<void>((resolve) => server.close(() => resolve()));
+ homeSpy.mockRestore();
+ fs.rmSync(root, { recursive: true, force: true });
+ for (const pid of nativePids) expect(() => process.kill(pid, 0)).toThrow();
+ }
+ }, 60_000);
+});
diff --git a/apps/desktop/src/main/maker-host/__tests__/codexPickerHarness.ts b/apps/desktop/src/main/maker-host/__tests__/codexPickerHarness.ts
new file mode 100644
index 0000000000..b8e4e806bf
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/__tests__/codexPickerHarness.ts
@@ -0,0 +1,137 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import ts from 'typescript';
+import { eq } from 'drizzle-orm';
+import type { Maker } from '../../../../../../packages/maker-core/src/maker.js';
+import type { DbClient } from '../../localDb/client/DbClient.js';
+import { sessions } from '../../localDb/schema.js';
+import * as providers from '../session-provider-store.js';
+import * as efforts from '../session-effort-store.js';
+import * as routeGuard from '../model-route-guard.js';
+import * as control from '../../maker-ipc/sessionRuntimeControl.js';
+import * as axes from '../../maker-ipc/runtimeSelectionAxes.js';
+import * as relink from '../../maker-ipc/codexProviderThreadRelink.js';
+import * as windowGate from '../../../shared/runtimeModelSwitchGate.js';
+import * as overflow from '../../maker-ipc/contextOverflowRollover.js';
+import { applyRuntimeSetModelChange } from '../../maker-ipc/runtimeSetModel.js';
+import { normalizeDeviceLinkSetModelWireArgs } from '../../maker-ipc/setModelWireArgs.js';
+import { CredentialModeSwitchBusyError } from '../codex-credential-switch.js';
+import { createPendingAgentSwitchRegistry, applyPendingAgentSwitchIfIdle, projectPendingAgentSwitchIntent, type MakerSessionAgentSwitchHandlerDeps } from '../../maker-ipc/sessionAgentSwitchHandler.js';
+import { registerSessionSetModelHandler } from '../../maker-ipc/sessionSetModelHandler.js';
+import { registerMakerSessionSendHandler } from '../../maker-ipc/sessionSendHandler.js';
+import { createMakerSendTransaction, type MakerSendTransactionDeps } from '../../maker-ipc/makerSendTransaction.js';
+import { acquireSendToSessionLock, withSendToSessionLock } from '../../maker-ipc/sendToSessionLock.js';
+import type { IpcHandler } from '../../maker-ipc/ipcHandlerRegistry.js';
+import { MAKER_INVOKE } from '../../maker-ipc/channels.js';
+import { createSharedTaskSettingGuard } from '../../maker-ipc/sharedTaskSetting.js';
+
+// Execute the full production closures, not copied branches or source assertions.
+// Electron ingress, owner, catalog metadata and UI broadcasts are fixture inputs;
+// pending selection, runtime replacement, native fork and SQLite CAS stay real.
+const source = fs.readFileSync(path.resolve(__dirname, '../../maker-ipc/register.ts'), 'utf8');
+const ast = ts.createSourceFile('register.ts', source, ts.ScriptTarget.Latest, true);
+function closure(name: string): string {
+ let expression: ts.Expression | undefined;
+ const visit = (node: ts.Node) => {
+ if (ts.isVariableDeclaration(node) && node.name.getText(ast) === name) expression = node.initializer;
+ if (ts.isPropertyAssignment(node) && node.name.getText(ast) === name && ts.isArrowFunction(node.initializer)) expression = node.initializer;
+ if (ts.isBinaryExpression(node) && node.left.getText(ast) === name && ts.isArrowFunction(node.right)) expression = node.right;
+ ts.forEachChild(node, visit);
+ };
+ visit(ast);
+ if (!expression) throw new Error(`Missing production closure ${name}`);
+ return ts.transpileModule(`(${expression.getText(ast)})`, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText;
+}
+
+export function createCodexPickerHarness(input: {
+ maker: Maker;
+ db: Pick<DbClient, 'drizzle'>;
+ workingDir: string;
+ createMessage(id: string, message: { clientId: string; content: unknown }): Promise<unknown>;
+}) {
+ const { maker, db, workingDir } = input;
+ const pending = createPendingAgentSwitchRegistry();
+ const noop = () => {};
+ const asyncNoop = async () => {};
+ const log = { info: noop, warn: noop, debug: noop, error: noop };
+ const readRow = async (id: string) => (await db.drizzle.select().from(sessions).where(eq(sessions.id, id)).limit(1))[0];
+ const bootstrap = async (id: string) => {
+ const row = await readRow(id);
+ return maker.createSession({ id, agentKind: 'codex', model: row.model!, providerId: row.providerId,
+ resumeSessionId: row.sdkSessionId ?? undefined, workingDir });
+ };
+ const env: Record<string, unknown> = {
+ ...providers, ...efforts, ...routeGuard, ...control, ...axes, ...relink, ...windowGate, ...overflow,
+ maker, sessions, eq, log, agentSwitchPending: pending,
+ // Ordinary local picker has no shared-task invocation context.
+ captureSharedTaskSettingGuard: (id: string) => createSharedTaskSettingGuard(undefined, id, { admitted: false }),
+ normalizeDeviceLinkSetModelWireArgs, applyRuntimeSetModelChange, CredentialModeSwitchBusyError,
+ projectPendingAgentSwitchIntent, acquireSendToSessionLock, withSendToSessionLock, applyPendingAgentSwitchIfIdle,
+ getDbClient: () => db, getCurrentDbClientSnapshot: () => ({ client: db, clientEpoch: 1 }),
+ captureDataOwnerBroadcastScope: () => 'synthetic-owner', isDataOwnerBroadcastScopeCurrent: () => true,
+ assertReviewSettingsUnlocked: asyncNoop, isDeviceLinkInvoke: () => false,
+ deviceLinkInvokeControllerSupports: () => false, CONTROLLER_CAPABILITY_SET_MODEL_EXPLICIT_PROVIDER_NULL_V1: 'fixture',
+ throwIpcError: (code: string, message: string) => { throw new Error(`${code}: ${message}`); },
+ dbToMakerAgentKind: (kind: string) => kind, getSessionDbAgentKind: () => 'codex',
+ assertModelRouteUsable: asyncNoop, shouldApplyExclusiveProviderRerouteLive: () => false,
+ clearPendingCredentialSwitchForSession: noop, registerPendingCredentialSwitchForSession: noop,
+ getPendingCredentialSwitchTarget: () => undefined, pendingCredentialSwitchHolder: null,
+ wakeSessionInputAfterCredentialSwitch: noop, broadcastSessionPatched: noop,
+ broadcastSessionRuntimeProjection: asyncNoop, recordSessionContextSnapshot: asyncNoop,
+ isSessionInTurn: (id: string) => maker.getSession(id)?.isTurnRunning() ?? false,
+ getCodexProxyAuthInjectionState: () => 'oauth-bearer',
+ getActiveCatalog: () => ({}), resolveConfiguredContextWindow: () => 258400,
+ getDesktopProviderService: () => ({ listProviders: async () => ['openai', 'xd', 'cprov-fixture'].map(id => ({ id, connected: true })) }),
+ findCatalogModel: () => ({ id: 'fixture-model', efforts: ['high'], contextWindow: 258400, supportsFastMode: false }),
+ reconcileBotModelRoute: asyncNoop, contextOverflowRolloverHolder: null,
+ withRehydrateCloseSuppressed: async (_id: string, run: () => Promise<unknown>) => run(),
+ persistSessionFields: async (id: string, patch: Partial<typeof sessions.$inferInsert>) => db.drizzle.update(sessions).set(patch).where(eq(sessions.id, id)),
+ };
+ const context = vm.createContext(env);
+ type Apply = (id: string, model: string, providerId: string | null | undefined, revision: unknown, selection: unknown, options: Record<string, unknown>) => Promise<{ deferred?: boolean; superseded?: boolean }>;
+ const apply = vm.runInContext(closure('handleSetModel'), context) as Apply;
+ env.applySessionRuntimeSelection = (id: string, model: string, providerId: string | null | undefined, selection: unknown, options: Record<string, unknown>) => apply(id, model, providerId, undefined, selection, options);
+ const switchDeps = {
+ pendingSwitches: pending, getLiveSession: (id: string) => maker.getSession(id),
+ bootstrapSwitchedSession: bootstrap, log,
+ selectSameAgentModel: vm.runInContext(closure('selectSameAgentModel'), context),
+ } as unknown as MakerSessionAgentSwitchHandlerDeps;
+ env.agentSwitchDeps = switchDeps;
+ const beforeSend = vm.runInContext(closure('pendingAgentSwitchApplyHolder'), context) as (id: string) => Promise<{ release(): void }>;
+ const transactionDeps: MakerSendTransactionDeps = {
+ getSession: id => maker.getSession(id), closeSession: id => maker.closeSession(id), getSessionMeta: id => maker.getSessionMeta(id),
+ preflightBotRuntimeResources: asyncNoop, ensureRemoteReadyForSessionStart: asyncNoop,
+ checkWorkDirExists: async () => true, readSessionWorkingDirFromDb: async () => workingDir,
+ readWorkingDirectoryRecoveryCreateOpts: async id => {
+ const row = await readRow(id);
+ return { id, agentKind: 'codex', model: row.model ?? undefined, providerId: row.providerId,
+ resumeSessionId: row.sdkSessionId ?? undefined, workingDir };
+ },
+ isOrcaMcpHydrated: () => true, buildCreateOptsWithStderr: opts => opts,
+ synthesizeOrcaVendorOptionsFromDb: async () => false, readSessionExtraDirsFromDb: async () => [],
+ withRehydrateCloseSuppressed: async (_id, run) => run(),
+ bootstrapSession: async opts => ({ session: await bootstrap(opts.id!), didInjectOrcaInstructions: false, didInjectProjectContext: false }),
+ markOrcaRoleIfNeeded: asyncNoop, broadcastSessionCreated: noop,
+ prepareSendUserMessage: async (_id, message) => message as string,
+ createDbMessage: input.createMessage, isSessionRunningError: () => false, log,
+ };
+ const transaction = createMakerSendTransaction(transactionDeps);
+ const handlers = new Map<string, IpcHandler>();
+ const registry = { handle: (channel: string, handler: IpcHandler) => { handlers.set(channel, handler); } };
+ registerSessionSetModelHandler(registry, { isDeviceLinkInvoke: () => false, assertTrustedSender: noop,
+ apply: (id, model, providerId, revision, selection) => apply(id as string, model as string, providerId as string, revision, selection, { source: 'user' }),
+ });
+ registerMakerSessionSendHandler(registry, { sendToAgentAccepted: async (id, message, opts, sendOpts) => {
+ const lease = await beforeSend(id);
+ try { return await transaction.sendToAgentAccepted(id, message, opts, sendOpts); }
+ finally { lease.release(); }
+ } });
+ return {
+ pending,
+ pick: (id: string, providerId: string, model = 'fixture-model') => handlers.get(MAKER_INVOKE.SET_MODEL)!(null, id, model, providerId),
+ send: (id: string, clientId: string) => handlers.get(MAKER_INVOKE.SEND)!(null, id, 'picker fixture',
+ { id, agentKind: 'codex', model: 'fixture-model', workingDir },
+ { messageUuid: clientId, persistUserMessage: { clientId, content: 'picker fixture' } }),
+ };
+}
diff --git a/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts
index 4eb1034a42..7184742fc5 100644
--- a/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts
@@ -8135,6 +8135,233 @@ describe('createModelRoutingTransform —— custom Provider native imagegen pre
}
});
+ it('selects namespaced smart children before routing, preserving lineage and frozen authorization', async () => {
+ const received: Array<{ path: string; body: Record<string, unknown>; key: string; account: unknown }> = [];
+ const upstream = createServer(async (req, res) => {
+ const chunks: Buffer[] = [];
+ for await (const chunk of req) chunks.push(Buffer.from(chunk));
+ received.push({ path: req.url ?? '', body: JSON.parse(Buffer.concat(chunks).toString()),
+ key: String(req.headers.authorization), account: req.headers['chatgpt-account-id'] });
+ res.writeHead(200, { 'content-type': 'application/json' }).end('{}');
+ });
+ await new Promise<void>(resolve => upstream.listen(0, '127.0.0.1', resolve));
+ const host = await freshCodexProxyHost();
+ const actual = await vi.importActual<typeof import('@cindy/anthropic-compat-proxy')>('@cindy/anthropic-compat-proxy');
+ mockState.createAnthropicCompatProxy.mockImplementationOnce(actual.createAnthropicCompatProxy);
+ const { BUNDLED_CATALOG, buildUserProvider } = await import('@cindy/model-providers');
+ const { setActiveCatalog } = await import('../active-catalog.js');
+ const routing = await import('../provider-route.js');
+ const sessions = await import('../session-provider-store.js');
+ const { deriveCodexCustomProviderRoutes } = await import('../codex-custom-provider-route.js');
+ const endpoint = `http://127.0.0.1:${(upstream.address() as AddressInfo).port}`;
+ const providers = ['parent', 'child', 'nested'].map(id => buildUserProvider({
+ id: `cprov-${id}`, name: id, runtimes: { codex: {
+ baseUrl: `${endpoint}/${id}`, wireProtocol: 'openai-responses', supportsImageGeneration: true,
+ models: [{ id: `${id}-model`, name: id, reasoning: true, reasoningEfforts: ['high'] }],
+ } },
+ }));
+ const catalog = { ...BUNDLED_CATALOG, providers: [...BUNDLED_CATALOG.providers, ...providers] };
+ setActiveCatalog(catalog);
+ const readKey = vi.fn((id: string) => `synthetic-${id}`);
+ routing.setCustomProviderKeyReader(readKey);
+ const routes = deriveCodexCustomProviderRoutes(catalog);
+ const parent = routes.find(route => route.providerId === 'cprov-parent')!;
+ const candidates = providers.map(provider => ({ providerId: provider.id,
+ catalogModel: provider.models.codex![0]!.id, reasoningEffort: 'high' as const }));
+ sessions.setSessionProvider('smart-source', 'cprov-parent');
+ const register = (fixed = false) => host.registerComposed('smart-source', 'root', 'fixture', {
+ smartSubagentRoutes: candidates,
+ ...(fixed ? { subagentRoute: candidates[1] } : {}),
+ });
+ register();
+ try {
+ await host.ensureCodexCustomContextProxyReady('smart-namespace', 'provider-oauth', routes);
+ const proxy = host.getCodexCustomContextProxyEndpoint('smart-namespace');
+ const post = async (model: string, thread: string, parentThread?: string, kind = 'collab_spawn', routeId = parent.routeId) => {
+ const response = await fetch(`${proxy}/_cindy/custom-provider/${routeId}/responses`, {
+ method: 'POST', headers: { 'content-type': 'application/json', 'thread-id': thread,
+ 'chatgpt-account-id': 'must-not-leak',
+ ...(parentThread ? { 'x-codex-parent-thread-id': parentThread, 'x-openai-subagent': kind } : {}) },
+ body: JSON.stringify({ model, input: [], vendor_field: 'retain', reasoning: { effort: 'low', summary: 'auto' } }),
+ });
+ await response.text();
+ return response.status;
+ };
+ // Before any thread notification: the genuine first collab request selects its candidate.
+ expect(await post('child-model', 'child', 'root')).toBe(200);
+ expect(received.at(-1)).toMatchObject({ path: '/child/responses', key: 'Bearer synthetic-cprov-child',
+ account: undefined, body: { model: 'child-model', vendor_field: 'retain', reasoning: { effort: 'high', summary: 'auto' } } });
+ expect(host.registerChildThread('root', 'child')).toBe(true);
+ expect(await post('nested-model', 'grandchild', 'child')).toBe(200);
+ expect(host.registerChildThread('child', 'grandchild')).toBe(true);
+ expect(await post('nested-model', 'grandchild', 'child')).toBe(200);
+ expect(received.at(-1)).toMatchObject({ path: '/nested/responses', key: 'Bearer synthetic-cprov-nested', body: { model: 'nested-model' } });
+ expect(await post('parent-model', 'same-provider', 'root')).toBe(200);
+ expect(received.at(-1)?.path).toBe('/parent/responses');
+ expect(await post('parent-model', 'root')).toBe(200);
+ expect(received.at(-1)?.body).toMatchObject({ model: 'parent-model', vendor_field: 'retain' });
+ const before = received.length;
+ readKey.mockClear();
+ expect(await post('child-model', 'unknown-child', 'unknown-parent')).toBe(403);
+ expect(await post('child-model', 'guardian', 'root', 'guardian')).toBe(403);
+ expect(await post('child-model', 'unmarked')).toBe(403);
+ expect(await post('foreign-model', 'unselected', 'root')).toBe(403);
+ expect(await post('child-model', 'forged', 'root', 'collab_spawn', 'bbbbbbbbbbbbbbbbbbbb')).toBe(403);
+ expect(readKey).not.toHaveBeenCalled();
+ const finish = routing.beginProviderRouteMutation('cprov-child');
+ try { expect(await post('child-model', 'child', 'root')).toBe(503); }
+ finally { finish.commit(); finish(); }
+ expect(await post('child-model', 'child', 'root')).toBe(503);
+ expect(received).toHaveLength(before);
+ expect(readKey).not.toHaveBeenCalled();
+ host.unregister('smart-source');
+ expect(await post('child-model', 'child', 'root')).toBe(403);
+ // A legacy locked route still overrides native inheritance, even with smart candidates present.
+ register(true);
+ expect(await post('parent-model', 'locked', 'root')).toBe(200);
+ expect(received.at(-1)).toMatchObject({ path: '/child/responses', body: { model: 'child-model', reasoning: { effort: 'high' } } });
+ expect(await post('nested-model', 'locked-nested', 'locked')).toBe(200);
+ expect(received.at(-1)?.body.model).toBe('child-model');
+ // A credential read is an await boundary in route resolution: neither a
+ // committed mutation nor unregister may dispatch the captured old decision.
+ for (const change of ['mutation', 'unregister'] as const) {
+ host.unregister('smart-source');
+ register();
+ const count = received.length;
+ readKey.mockImplementationOnce((id) => {
+ if (change === 'mutation') {
+ const done = routing.beginProviderRouteMutation(id); done.commit(); done();
+ } else host.unregister('smart-source');
+ return `synthetic-${id}`;
+ });
+ expect(await post('child-model', `read-race-${change}`, 'root')).toBe(503);
+ expect(received).toHaveLength(count);
+ }
+ } finally {
+ host.unregister('smart-source');
+ sessions.clearSessionProvider('smart-source');
+ await host.releaseCodexCustomContextProxy('smart-namespace');
+ routing.setCustomProviderKeyReader(() => null);
+ setActiveCatalog(BUNDLED_CATALOG);
+ upstream.closeAllConnections();
+ await new Promise<void>(resolve => upstream.close(() => resolve()));
+ }
+ });
+
+ it('runs the existing xAI outbound chain once for authorized namespace escapes, like ordinary Responses', async () => {
+ const received: Array<{ body: Record<string, unknown>; auth: unknown; account: unknown }> = [];
+ const server = createServer(async (req, res) => {
+ const chunks: Buffer[] = [];
+ for await (const chunk of req) chunks.push(Buffer.from(chunk));
+ received.push({ body: JSON.parse(Buffer.concat(chunks).toString()), auth: req.headers.authorization,
+ account: req.headers['chatgpt-account-id'] });
+ res.writeHead(200, { 'content-type': 'application/json' }).end('{}');
+ });
+ await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+ const host = await freshCodexProxyHost();
+ const actual = await vi.importActual<typeof import('@cindy/anthropic-compat-proxy')>('@cindy/anthropic-compat-proxy');
+ mockState.createAnthropicCompatProxy.mockImplementationOnce(actual.createAnthropicCompatProxy);
+ const { BUNDLED_CATALOG, buildUserProvider } = await import('@cindy/model-providers');
+ const catalog = await import('../active-catalog.js');
+ const routing = await import('../provider-route.js');
+ const sessions = await import('../session-provider-store.js');
+ const { deriveCodexCustomProviderRoutes } = await import('../codex-custom-provider-route.js');
+ const { selectCodexSmartSubagentCandidates } = await import('../codex-smart-subagent-routing.js');
+ const endpoint = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+ const parent = buildUserProvider({ id: 'cprov-wire', name: 'Synthetic parent', runtimes: { codex: {
+ baseUrl: endpoint, wireProtocol: 'openai-responses', supportsImageGeneration: true,
+ models: [{ id: 'api-parent', name: 'Parent', reasoningEfforts: ['high'] }],
+ } } });
+ // Use the bundled contract, changing only the network destination to loopback.
+ const xai = structuredClone(BUNDLED_CATALOG.providers.find(provider => provider.id === 'xai')!);
+ xai.routing.codex!.upstream = endpoint;
+ catalog.setActiveCatalog({ ...BUNDLED_CATALOG, providers: [parent, xai] });
+ routing.setCustomProviderKeyReader(() => 'synthetic-parent');
+ const readOAuth = vi.fn(async () => 'synthetic-xai');
+ routing.setProviderOAuthTokenReader(readOAuth);
+ const candidates = selectCodexSmartSubagentCandidates([parent, xai].map(provider => ({ ...provider, connected: true, agents: ['codex'] })),
+ { allowChatGptOAuth: true, oauthProviderId: parent.id });
+ expect(candidates.some(candidate => candidate.providerId === 'xai' && candidate.model.id === 'xai/grok-4.7')).toBe(true);
+ const routes = deriveCodexCustomProviderRoutes(catalog.getActiveCatalog());
+ const route = routes.find(item => item.providerId === parent.id)!;
+ sessions.setSessionProvider('wire-source', parent.id);
+ const register = () => host.registerComposed('wire-source', 'wire-root', 'synthetic', {
+ smartSubagentRoutes: candidates.map(candidate => ({ providerId: candidate.providerId, catalogModel: candidate.model.id, reasoningEffort: 'high' })),
+ });
+ register();
+ let release = () => {};
+ try {
+ await host.ensureCodexCustomContextProxyReady('wire-scope', 'provider-oauth', routes);
+ const proxy = host.getCodexCustomContextProxyEndpoint('wire-scope');
+ const namespace = `/_cindy/custom-provider/${route.routeId}/responses`;
+ const body = { model: 'xai/grok-4.7', input: [], instructions: 'synthetic instructions',
+ reasoning: { effort: 'low' }, tools: [{ type: 'namespace', name: 'multi_agent_v1', tools: [] }] };
+ const post = async (url: string, payload = body, thread = 'wire-child', parentThread = 'wire-root') => {
+ const response = await fetch(proxy + url, { method: 'POST', headers: {
+ 'content-type': 'application/json', 'thread-id': thread, 'chatgpt-account-id': 'must-not-leak',
+ ...(parentThread ? { 'x-codex-parent-thread-id': parentThread, 'x-openai-subagent': 'collab_spawn' } : {}),
+ }, body: JSON.stringify(payload) });
+ await response.text(); return response.status;
+ };
+ expect(await post(namespace)).toBe(200);
+ const escaped = received.at(-1)!;
+ expect(escaped).toMatchObject({ auth: 'Bearer synthetic-xai', account: undefined,
+ body: { model: 'grok-4.7', reasoning: { effort: 'high' }, tools: [{ type: 'x_search' }],
+ input: [{ type: 'message', role: 'system', content: 'synthetic instructions' }] } });
+ expect(escaped.body.tools).toEqual([{ type: 'x_search' }]);
+ expect(escaped.body.input).toHaveLength(1);
+ expect(readOAuth).toHaveBeenCalledTimes(1);
+ expect(mockState.injectionTransform).toHaveBeenCalledTimes(1);
+ expect(await post('/responses')).toBe(200);
+ expect(received.at(-1)).toEqual(escaped);
+ expect(readOAuth).toHaveBeenCalledTimes(2);
+ expect(mockState.injectionTransform).toHaveBeenCalledTimes(2);
+ // Same-provider namespace children and parent requests must not inherit the
+ // previous request's authorization to run the ordinary outbound chain.
+ const parentBody = { ...body, model: 'api-parent', reasoning: { effort: 'high' } };
+ expect(await post(namespace, parentBody, 'wire-root', '')).toBe(200);
+ expect(received.at(-1)?.body).toEqual(parentBody);
+ expect(await post(namespace, parentBody, 'same-provider')).toBe(200);
+ expect(received.at(-1)?.body).toEqual(parentBody);
+ expect(mockState.injectionTransform).toHaveBeenCalledTimes(2);
+ // Changing ownership or routing during the token read must not enable the chain.
+ for (const change of ['mutation', 'unregister'] as const) {
+ host.unregister('wire-source'); register();
+ let entered!: () => void;
+ const reading = new Promise<void>(resolve => { entered = resolve; });
+ const gate = new Promise<void>(resolve => { release = resolve; });
+ readOAuth.mockImplementationOnce(async () => { entered(); await gate; return 'synthetic-xai'; });
+ const count = received.length;
+ const pending = post(namespace, body, `race-${change}`);
+ await reading;
+ if (change === 'mutation') {
+ const finish = routing.beginProviderRouteMutation('xai'); finish.commit(); finish();
+ } else host.unregister('wire-source');
+ release();
+ expect(await pending).toBe(503);
+ expect(received).toHaveLength(count);
+ expect(mockState.injectionTransform).toHaveBeenCalledTimes(2);
+ }
+ // Authorization remains checked after the newly enabled transform chain.
+ host.unregister('wire-source'); register();
+ mockState.injectionTransform.mockImplementationOnce(() => {
+ const finish = routing.beginProviderRouteMutation('xai'); finish.commit(); finish();
+ return null;
+ });
+ const count = received.length;
+ expect(await post(namespace, body, 'transform-race')).toBe(503);
+ expect(received).toHaveLength(count);
+ expect(mockState.injectionTransform).toHaveBeenCalledTimes(3);
+ expect(readOAuth).toHaveBeenCalledTimes(5);
+ } finally {
+ release(); host.unregister('wire-source'); sessions.clearSessionProvider('wire-source');
+ await host.releaseCodexCustomContextProxy('wire-scope');
+ catalog.setActiveCatalog(BUNDLED_CATALOG); routing.setCustomProviderKeyReader(() => null);
+ routing.setProviderOAuthTokenReader(async () => null);
+ server.closeAllConnections(); await new Promise<void>(resolve => server.close(() => resolve()));
+ }
+ });
+
it('owns every private custom Provider prefix before opaque body transforms', async () => {
const host = await freshCodexProxyHost();
mockState.createAnthropicCompatProxy.mockResolvedValueOnce({
@@ -8168,3 +8395,104 @@ describe('createModelRoutingTransform —— custom Provider native imagegen pre
expect(options.routeOpaqueRequestBody({ url: '/images/edits' })).toBe(false);
});
});
+
+describe('official Subagents on external credential Hosts', () => {
+ it('invalidates a captured official child decision when its scoped proxy retires', async () => {
+ const host = await freshCodexProxyHost();
+ mockState.createAnthropicCompatProxy.mockResolvedValueOnce({ url: 'http://127.0.0.1:43210', dispose: vi.fn(async () => undefined) });
+ await host.ensureCodexCustomContextProxyReady('external-scope', 'provider-oauth', []);
+ host.setCodexSubagentOAuthReader(async () => ({ accessToken: 'synthetic-child', accountId: 'fixture', canDispatch: () => true }));
+ host.registerComposed('scoped-parent', 'scoped-parent-thread', 'fixture', {
+ subagentRoute: { providerId: 'openai', catalogModel: 'gpt-5.4', reasoningEffort: 'high' },
+ });
+ try {
+ const route = mockState.createAnthropicCompatProxy.mock.calls[0]?.[0]?.routingTransform;
+ if (!route) throw new Error('missing scoped routing transform');
+ const decision = await route({ model: 'gpt-5.4' }, { reqId: 1, method: 'POST', url: '/responses', headers: {
+ 'thread-id': 'scoped-child', 'x-openai-subagent': 'collab_spawn', 'x-codex-parent-thread-id': 'scoped-parent-thread',
+ } });
+ expect(decision?.dispatchGenerationValid?.()).toBe(true);
+ await host.releaseCodexCustomContextProxy('external-scope');
+ expect(decision?.dispatchGenerationValid?.()).toBe(false);
+ } finally { await host.disposeCodexProxy(); }
+ });
+
+ it.each(['env-key', 'provider-oauth'].flatMap((mode) => [false, true].map((revoked) => ({ mode, revoked }))))('reads host OAuth only for an explicit official child ($mode revoked=$revoked)', async ({ mode, revoked }) => {
+ const host = await freshCodexProxyHost();
+ mockState.createAnthropicCompatProxy.mockResolvedValueOnce({
+ url: 'http://127.0.0.1:43210', dispose: vi.fn(async () => undefined),
+ });
+ await host.ensureCodexProxyReady();
+ const canDispatch = vi.fn(() => true);
+ const reader = vi.fn(async () => {
+ if (revoked) throw new Error('synthetic revoked OAuth');
+ return { accessToken: 'synthetic-child-token', accountId: 'fixture-account', canDispatch };
+ });
+ host.setCodexSubagentOAuthReader(reader);
+ const { setSessionProvider, clearSessionProvider } = await import('../session-provider-store.js');
+ setSessionProvider('external-parent-session', 'external-fixture');
+ host.registerComposed('external-parent-session', 'external-parent-thread', 'fixture', {
+ subagentRoute: { providerId: 'openai', catalogModel: 'gpt-5.4', reasoningEffort: 'high' },
+ });
+ try {
+ const parentRoutes = [{
+ providerId: 'external-fixture', routeId: 'aaaaaaaaaaaaaaaaaaaa', modelProviderId: 'fixture',
+ capabilities: {}, responseModels: ['custom-parent-model'], credentialRevision: 0,
+ routing: { upstream: 'https://example.invalid', authStrategy: 'api-key-header' as const }, responseRoutingByModel: {}, responseEffortsByModel: {},
+ }];
+ const transform = host.createModelRoutingTransform(mode as 'env-key' | 'provider-oauth', parentRoutes);
+ await transform({ model: 'custom-parent-model' }, {
+ reqId: 1, method: 'POST', url: '/responses', headers: { 'thread-id': 'external-parent-thread' },
+ });
+ expect(reader).not.toHaveBeenCalled();
+ const decision = await transform({ model: 'gpt-5.4' }, {
+ reqId: 2, method: 'POST', url: '/_cindy/custom-provider/aaaaaaaaaaaaaaaaaaaa/responses', headers: {
+ 'thread-id': 'official-child-thread', 'x-openai-subagent': 'collab_spawn',
+ 'x-codex-parent-thread-id': 'external-parent-thread',
+ },
+ });
+ expect(reader).toHaveBeenCalledOnce();
+ if (revoked) {
+ expect(decision).toHaveProperty('localHandler');
+ } else {
+ expect(decision).toMatchObject({
+ upstreamOverride: 'https://chatgpt.com/backend-api/codex',
+ pathOverride: '/responses',
+ headerOverride: { authorization: 'Bearer synthetic-child-token', 'chatgpt-account-id': 'fixture-account' },
+ dispatchGenerationValid: expect.any(Function),
+ });
+ expect(decision?.dispatchGenerationValid?.()).toBe(true);
+ host.unregister('external-parent-session');
+ expect(decision?.dispatchGenerationValid?.()).toBe(false);
+ }
+ } finally {
+ clearSessionProvider('external-parent-session');
+ await host.disposeCodexProxy();
+ }
+ });
+});
+
+
+describe('external host proxy isolation', () => {
+ it('keeps subscription WebSocket routing when an external HTTP host starts and retires', async () => {
+ const host = await freshCodexProxyHost();
+ mockState.createAnthropicCompatProxy
+ .mockResolvedValueOnce({ url: 'http://127.0.0.1:41011', dispose: vi.fn(async () => undefined) })
+ .mockResolvedValueOnce({ url: 'http://127.0.0.1:41012', dispose: vi.fn(async () => undefined) });
+ host.setCodexProxyAuthInjection('oauth-bearer');
+ await host.ensureCodexProxyReady();
+ try {
+ await host.ensureCodexCustomContextProxyReady('local:external-auth:1', 'provider-oauth', []);
+ const official = mockState.createAnthropicCompatProxy.mock.calls[0][0];
+ const external = mockState.createAnthropicCompatProxy.mock.calls[1][0];
+ const context = { url: '/responses', headers: { 'thread-id': 'official-parent' } };
+ expect(host.getCodexProxyAuthInjection()).toBe('oauth-bearer');
+ expect(official.resolveWebSocketUpstream?.(context)).toBe('https://chatgpt.com/backend-api/codex');
+ expect(external.resolveWebSocketUpstream?.(context)).toBeNull();
+ await host.releaseCodexCustomContextProxy('local:external-auth:1');
+ expect(official.resolveWebSocketUpstream?.(context)).toBe('https://chatgpt.com/backend-api/codex');
+ } finally {
+ await host.disposeCodexProxy();
+ }
+ });
+});
diff --git a/apps/desktop/src/main/maker-host/__tests__/codexRouteTransaction.integration.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexRouteTransaction.integration.test.ts
new file mode 100644
index 0000000000..1d3a458499
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/__tests__/codexRouteTransaction.integration.test.ts
@@ -0,0 +1,599 @@
+import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import { getTableColumns } from 'drizzle-orm';
+import { createCodexPickerHarness } from './codexPickerHarness.js';
+import type { DbClient } from '../../localDb/client/DbClient.js';
+import { sessions } from '../../localDb/schema.js';
+import { commitCodexThreadTransfer, relinkCodexProviderThread, type CodexThreadTransferSnapshot } from '../../maker-ipc/codexProviderThreadRelink.js';
+import { applyRuntimeSetModelChange } from '../../maker-ipc/runtimeSetModel.js';
+import { clearSessionProvider, setSessionProvider } from '../session-provider-store.js';
+import type { Logger } from '../../../../../../packages/maker-core/src/interfaces/logger.js';
+import { AppServerHost } from '../../../../../../packages/maker-core/src/agents/codex/app-server/host.js';
+import { Maker } from '../../../../../../packages/maker-core/src/maker.js';
+import type { SessionMeta, SessionStorage } from '../../../../../../packages/maker-core/src/interfaces/session-storage.js';
+import { CodexAgent } from '../../../../../../packages/maker-core/src/agents/codex/index.js';
+import { buildUserProvider } from '@cindy/model-providers';
+import { setCustomProviders } from '../active-catalog.js';
+import { beginProviderRouteMutation, captureCodexLocalAuthPolicy } from '../provider-route.js';
+vi.mock('../../appCapabilities.js', () => ({ getAppCapabilities: () => ({ canUseCindyGateway: true }) }));
+
+// Explicit opt-in: never discover a user's installed runtime or credentials.
+const binaryPath = process.env.CINDY_TEST_CODEX_BINARY;
+const logger: Logger = {
+ trace() {}, debug() {}, info() {}, warn() {}, error() {}, fatal() {},
+ child: () => logger,
+};
+
+describe.skipIf(!binaryPath)('Desktop route transactions with real Codex app-server', () => {
+ it.each([...['A', 'B', 'C', 'initialize', 'capability', 'resume', 'transfer'].flatMap((window) => [false, true].map((reviewMode) => ({ window, reviewMode }))), ...['skills', 'config'].map((window) => ({ window, reviewMode: true })), ...['restricted', 'bot', 'local-skill', 'transfer-fork-failure', 'transfer-cas-failure', 'transfer-resume-failure', 'transfer-busy', 'transfer-retire-resolve-success', 'transfer-retire-resolve-failure', 'transfer-retire-list-success', 'transfer-retire-list-failure', 'transfer-picker', 'transfer-picker-shared', 'transfer-picker-resume-failure', 'transfer-picker-shared-resume-failure', 'transfer-picker-cold-task', 'transfer-picker-cold-control', 'transfer-picker-shared-cold-task', 'transfer-picker-shared-cold-control'].map((window) => ({ window, reviewMode: false }))])('waits for Desktop window $window with Review=$reviewMode before start and switch', async ({ window, reviewMode }) => {
+ const releases: Array<() => void> = [];
+ const beginMutation = () => { const finish = beginProviderRouteMutation('cprov-fixture'); releases.push(finish); return finish; };
+ const lateWindow = ['initialize', 'capability', 'resume', 'skills', 'config', 'restricted', 'bot', 'local-skill'].includes(window);
+ const revoked = !lateWindow && !window.startsWith('transfer');
+ const root = await mkdtemp(path.join(tmpdir(), 'cindy-codex-host-auth-'));
+ const home = path.join(root, 'codex');
+ const coldHome = path.join(root, 'cold-official');
+ const coldWindow = window.includes('cold-');
+ let releaseOAuth = () => {};
+ const oauthGate = new Promise<void>(resolve => { releaseOAuth = resolve; });
+ let refreshEntered = () => {};
+ const refreshRequested = new Promise<void>(resolve => { refreshEntered = resolve; });
+ let coldStart: Promise<unknown> | undefined;
+ let coldHost: AppServerHost | undefined;
+ let coldSettled = false;
+ let coldShutdown: { mockRestore: () => void } | undefined;
+ const workingDir = path.join(root, 'work');
+ await mkdir(home);
+ await mkdir(workingDir);
+ const calls: string[] = [];
+ let responseGate: Promise<void> | undefined;
+ let releaseResponse = () => {};
+ const server = createServer(async (req, res) => {
+ for await (const chunk of req) void chunk;
+ calls.push(`${req.method} ${req.url}`);
+ if (coldWindow && req.url === '/oauth/token') { refreshEntered(); await oauthGate; }
+ if (req.url === '/provider/responses') {
+ expect(req.headers.authorization).toBe('Bearer synthetic-invalid-api-key');
+ await responseGate;
+ res.writeHead(200, { 'content-type': 'text/event-stream', connection: 'close' });
+ const events = [
+ { type: 'response.created', response: { id: 'response-fixture' } },
+ { type: 'response.output_item.done', item: { type: 'message', role: 'assistant', id: 'message-fixture', content: [{ type: 'output_text', text: 'fixture complete' }] } },
+ { type: 'response.completed', response: { id: 'response-fixture', usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } } },
+ ];
+ res.end(events.map((event) => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`).join(''));
+ } else {
+ res.writeHead(401, { 'content-type': 'application/json' });
+ res.end(JSON.stringify({ error: { code: req.url === '/oauth/token' ? 'refresh_token_invalidated' : 'unauthorized', message: 'synthetic revoked token' } }));
+ }
+ });
+ await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+ const endpoint = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+ const authPath = path.join(home, 'auth.json');
+ let authFixture: string | undefined;
+ if (revoked) {
+ const encode = (value: unknown) => Buffer.from(JSON.stringify(value)).toString('base64url');
+ authFixture = JSON.stringify({
+ auth_mode: 'chatgpt', OPENAI_API_KEY: null,
+ tokens: {
+ id_token: `${encode({ alg: 'none', typ: 'JWT' })}.${encode({ email: '[email protected]', 'https://api.openai.com/auth': { chatgpt_plan_type: 'business', chatgpt_user_id: 'fixture-user', chatgpt_account_id: 'fixture-account' } })}.c3ludGhldGlj`,
+ access_token: 'synthetic-invalid-access-token', refresh_token: 'synthetic-invalid-refresh-token', account_id: 'fixture-account',
+ }, last_refresh: new Date().toISOString(),
+ });
+ await writeFile(authPath, authFixture, { mode: 0o600 });
+ }
+ await writeFile(path.join(home, 'config.toml'), [
+ 'model="fixture-model"', 'model_provider="fixture"', 'cli_auth_credentials_store="file"',
+ `chatgpt_base_url="${endpoint}"`, 'check_for_update_on_startup=false',
+ '[analytics]', 'enabled=false',
+ '[mcp_servers.cindy_memory]', 'command="/usr/bin/false"', 'enabled=false',
+ '[model_providers.fixture]', 'name="Fixture"', `base_url="${endpoint}/provider"`,
+ 'wire_api="responses"', 'env_key="FIXTURE_API_KEY"', 'requires_openai_auth=false', 'supports_websockets=false', 'request_max_retries=0',
+ ].join('\n'));
+ if (coldWindow) {
+ await mkdir(coldHome);
+ await writeFile(path.join(coldHome, 'config.toml'), `sqlite_home=${JSON.stringify(home)}\n` + (await readFile(path.join(home, 'config.toml'), 'utf8')));
+ const claims = { exp: 1, 'https://api.openai.com/auth': { chatgpt_plan_type: 'business', chatgpt_account_id: 'cold-official' } };
+ const token = `eyJhbGciOiJub25lIn0.${Buffer.from(JSON.stringify(claims)).toString('base64url')}.synthetic`;
+ await writeFile(path.join(coldHome, 'auth.json'), JSON.stringify({ auth_mode: 'chatgpt', tokens: {
+ id_token: token, access_token: token, refresh_token: 'synthetic-cold-refresh', account_id: 'cold-official',
+ }, last_refresh: '2000-01-01T00:00:00Z' }), { mode: 0o600 });
+ }
+ setCustomProviders([buildUserProvider({ id: 'cprov-fixture', name: 'Fixture', runtimes: { codex: { baseUrl: `${endpoint}/provider`, wireProtocol: 'openai-responses', models: [{ id: 'fixture-model', name: 'Fixture' }] } } })]);
+ const spawnConfigs: string[] = [];
+ let preparationGate: Promise<void> | undefined;
+ const preparationEntered = vi.fn();
+ let latePreparation: (() => Promise<void>) | undefined;
+ let rejectResumeRequest = false;
+ const agent = new CodexAgent({
+ binaryPath: binaryPath!, logger, runtimeConfig: {},
+ ...(window.includes('picker') && !window.includes('shared') ? { isolateCodexAccountSessions: true } : {}),
+ resolveCodexLocalAuthPolicy: captureCodexLocalAuthPolicy,
+ isCodexAccountProvider: providerId => providerId === 'account-cold',
+ ...(window === 'restricted' ? { capabilityRouting: { overrides: [{ capabilityId: 'computer-use', source: { kind: 'harness-plugin' as const, harness: 'codex' as const, surface: 'skill' as const, id: 'computer-use:computer-use', artifactId: 'computer-use', containerId: 'computer-use@openai-bundled' }, invocation: 'disabled' as const }] } } : {}),
+ ...(window === 'local-skill' ? { getDisabledSkillPaths: () => [path.join(root, 'disabled-skill')] } : {}),
+ resolveCapabilityRouting: async () => { if (window === 'capability') await latePreparation?.(); return undefined; },
+ prepareCodexResumeSession: async () => { preparationEntered(); if (window === 'resume') await latePreparation?.(); await preparationGate; return undefined; },
+ prepareCodexExtraSpawnConfig: async (_providers, ctx) => { spawnConfigs.push(ctx?.localAuthPolicy ?? 'legacy-shared'); return { extraArgs: [], extraEnv: {}, codexProxyActive: true }; },
+ auth: {
+ getState: async () => ({ authenticated: true }),
+ triggerLogin: async () => ({ authenticated: true }), logout: async () => {},
+ getAuthEnv: async (opts) => ({
+ HOME: root, CODEX_HOME: opts?.providerId === 'account-cold' ? coldHome : home, TMPDIR: root, FIXTURE_API_KEY: 'synthetic-invalid-api-key',
+ OPENAI_API_KEY: '', CODEX_API_KEY: '',
+ CODEX_REFRESH_TOKEN_URL_OVERRIDE: `${endpoint}/oauth/token`,
+ HTTP_PROXY: endpoint, HTTPS_PROXY: endpoint, ALL_PROXY: endpoint, NO_PROXY: '127.0.0.1,localhost',
+ }),
+ },
+ });
+ const spies: Array<{ mockRestore: () => void }> = [];
+ try {
+ if (window.startsWith('transfer')) {
+ const sqlite = new Database(':memory:');
+ sqlite.exec('CREATE TABLE sessions (id TEXT PRIMARY KEY, status TEXT, agent_kind TEXT, remote_host_id TEXT, sdk_session_id TEXT, model TEXT, provider_id TEXT, effort TEXT, fast_mode INTEGER, updated_at INTEGER)');
+ if (window.includes('picker')) {
+ const existing = new Set((sqlite.prepare('PRAGMA table_info(sessions)').all() as Array<{ name: string }>).map(column => column.name));
+ for (const column of Object.values(getTableColumns(sessions))) {
+ if (!existing.has(column.name)) sqlite.exec(`ALTER TABLE sessions ADD COLUMN "${column.name}" ${column.getSQLType()}`);
+ }
+ sqlite.exec('CREATE TABLE picker_messages (client_id TEXT PRIMARY KEY, session_id TEXT, content TEXT)');
+ }
+ const db = { drizzle: drizzle(sqlite) } as unknown as Pick<DbClient, 'drizzle'>;
+ const rows = new Map<string, SessionMeta>();
+ const storage: SessionStorage = {
+ create: async (meta) => {
+ const row = { ...meta, createdAt: 1, updatedAt: 1 }; rows.set(row.id, row);
+ sqlite.prepare('INSERT INTO sessions (id,status,agent_kind,remote_host_id,sdk_session_id,model,provider_id,effort,fast_mode,updated_at) VALUES (?, ?, ?, NULL, ?, ?, ?, ?, ?, ?)').run(row.id, 'active', 'codex', row.sdkSessionId ?? null, row.model, 'openai', 'high', 0, 1);
+ if (window.includes('picker')) sqlite.prepare('UPDATE sessions SET working_dir = ?, context_tokens = 1, context_window = 258400 WHERE id = ?').run(workingDir, row.id);
+ return row;
+ },
+ get: async (id) => {
+ const persisted = sqlite.prepare('SELECT sdk_session_id AS sdkSessionId, model FROM sessions WHERE id = ?').get(id) as { sdkSessionId: string; model: string } | undefined;
+ return rows.has(id) ? { ...rows.get(id)!, ...persisted } : null;
+ },
+ list: async () => [...rows.values()],
+ update: async (id, patch) => {
+ const row = { ...rows.get(id)!, ...patch }; rows.set(id, row);
+ if (patch.sdkSessionId) sqlite.prepare('UPDATE sessions SET sdk_session_id = ? WHERE id = ?').run(patch.sdkSessionId, id);
+ return row;
+ },
+ compareAndClearSdkSessionId: async () => false,
+ delete: async (id) => { rows.delete(id); },
+ };
+ const maker = new Maker({ agents: { codex: agent }, storage, logger });
+ const send = async (session: NonNullable<ReturnType<Maker['getSession']>>) => {
+ let off: () => void = () => {};
+ const done = new Promise<void>((resolve, reject) => {
+ off = session.onEvent((event) => {
+ if (event.type === 'error') { off(); reject(new Error(JSON.stringify(event))); }
+ if (event.type === 'done') { off(); resolve(); }
+ });
+ });
+ const result = await session.send('fixture transfer');
+ if (!result.accepted) { off(); return; }
+ await done;
+ };
+ const acceptedForks: AppServerHost[] = [];
+ const request = AppServerHost.prototype.request;
+ const requestSpy = vi.spyOn(AppServerHost.prototype, 'request').mockImplementation(function (this: AppServerHost, method, params, opts) {
+ if (method === 'thread/resume' && rejectResumeRequest) {
+ rejectResumeRequest = false;
+ params = { ...params as object, modelProvider: 'missing-fixture-provider' };
+ }
+ return request.call(this, method, params, { ...opts, beforeDispatch: () => {
+ opts?.beforeDispatch?.(); if (method === 'thread/fork') acceptedForks.push(this);
+ } });
+ });
+ spies.push(requestSpy);
+ try {
+ setSessionProvider('source', 'openai');
+ const retirementWindow = window.startsWith('transfer-retire');
+ const sibling = await maker.createSession({ id: 'unrelated', agentKind: 'codex', providerId: retirementWindow ? 'cprov-fixture' : 'openai', model: 'fixture-model', workingDir });
+ let source = await maker.createSession({ id: 'source', agentKind: 'codex', providerId: 'openai', model: 'fixture-model', workingDir, ...(reviewMode ? { reviewMode: true as const } : {}) });
+ await send(source);
+ const hostMap = (agent as unknown as { hosts: Map<string, AppServerHost> }).hosts;
+ const siblingHost = hostMap.get(sibling.codexHostKey ?? (retirementWindow ? 'local:external-auth' : 'local'))!;
+ const connection = siblingHost.getConnectionId();
+ if (window.includes('picker')) {
+ const picker = createCodexPickerHarness({ maker, db, workingDir, createMessage: async (id, message) => {
+ sqlite.prepare('INSERT INTO picker_messages VALUES (?, ?, ?)').run(message.clientId, id, JSON.stringify(message.content));
+ } });
+ const routes = coldWindow ? ['xd', 'xd', 'openai', 'cprov-fixture', 'cprov-fixture', 'openai'] : ['xd', 'openai', 'cprov-fixture', 'openai'];
+ for (const [index, providerId] of routes.entries()) {
+ if (coldWindow && index === 1) {
+ const start = window.endsWith('control')
+ ? agent.readAccountRateLimits('account-cold')
+ : agent.startSession({ sessionId: 'cold-official', providerId: 'account-cold', model: 'fixture-model', workingDir });
+ coldStart = start.then(() => { coldSettled = true; }, () => { coldSettled = true; });
+ await refreshRequested;
+ coldHost = [...hostMap].find(([key]) => key.includes('account-cold'))![1];
+ coldShutdown = vi.spyOn(coldHost, 'shutdown');
+ spies.push(coldShutdown);
+ }
+ const sameHostModelChange = coldWindow && routes[index - 1] === providerId;
+ const previousSession = source;
+ const original = (await storage.get('source'))!.sdkSessionId;
+ const originalPath = await (agent as unknown as { findRolloutPath(id: string): Promise<string> }).findRolloutPath(original!);
+ const originalHistory = await readFile(originalPath, 'utf8');
+ const forksBefore = acceptedForks.length;
+ const requestsBefore = calls.filter(call => call === 'POST /provider/responses').length;
+ expect(await picker.pick('source', providerId, coldWindow && (index === 1 || index === 4) ? 'fixture-model-two' : 'fixture-model')).toMatchObject({ deferred: true, pendingUntilSend: true });
+ expect((await storage.get('source'))!.sdkSessionId).toBe(original);
+ expect(maker.getSession('source')).toBe(source);
+ expect(acceptedForks).toHaveLength(forksBefore);
+ expect(sqlite.prepare('SELECT orca_role FROM sessions WHERE id = ?').get('source')).toEqual({ orca_role: null });
+ if (window.endsWith('resume-failure') && index === 0) {
+ rejectResumeRequest = true;
+ await expect(picker.send('source', `picker-${index}`)).rejects.toThrow(/provider/i);
+ expect(sqlite.prepare('SELECT count(*) AS n FROM picker_messages').get()).toEqual({ n: 0 });
+ expect(calls.filter(call => call === 'POST /provider/responses')).toHaveLength(requestsBefore);
+ }
+ expect(await picker.send('source', `picker-${index}`)).toMatchObject({ accepted: true });
+ source = maker.getSession('source')!;
+ if (sameHostModelChange) {
+ expect(source.codexHostKey).toBe(previousSession.codexHostKey);
+ expect((await storage.get('source'))!.sdkSessionId).toBe(original);
+ expect((await storage.get('source'))!.model).toBe('fixture-model-two');
+ }
+ await expect.poll(() => source.isTurnRunning()).toBe(false);
+ expect(calls.filter(call => call === 'POST /provider/responses')).toHaveLength(requestsBefore + 1);
+ expect(sqlite.prepare('SELECT count(*) AS n FROM picker_messages').get()).toEqual({ n: index + 1 });
+ expect(picker.pending.get('source')).toBeUndefined();
+ expect(sqlite.prepare('SELECT provider_id FROM sessions WHERE id = ?').get('source')).toEqual({ provider_id: providerId });
+ expect(acceptedForks.length - forksBefore).toBe(window.includes('shared') && routes[index - 1] !== providerId ? 1 : 0);
+ const currentHistory = await readFile(originalPath, 'utf8');
+ if (acceptedForks.length > forksBefore) expect(currentHistory).toBe(originalHistory);
+ else expect(currentHistory.startsWith(originalHistory)).toBe(true);
+ expect([...hostMap.keys()].some(key => key.startsWith('local-fork:'))).toBe(false);
+ expect(siblingHost.getConnectionId()).toBe(connection);
+ await send(sibling);
+ if (coldHost) {
+ expect(coldSettled).toBe(false);
+ expect(coldShutdown).not.toHaveBeenCalled();
+ expect(coldHost.hasStarted).toBe(true);
+ expect(coldHost.writerCandidate).toBeNull();
+ expect(requestSpy.mock.contexts.some((host, i) => host === coldHost && requestSpy.mock.calls[i][0] === 'thread/loaded/list')).toBe(false);
+ }
+ }
+ return;
+ }
+ if (retirementWindow) {
+ await maker.closeSession('source');
+ const sourceRow = (await db.drizzle.select({ id: sessions.id, sdkSessionId: sessions.sdkSessionId, model: sessions.model, providerId: sessions.providerId, effort: sessions.effort, fastMode: sessions.fastMode, updatedAt: sessions.updatedAt }).from(sessions)).find((row) => row.id === 'source')!;
+ const sourceHost = hostMap.get('local')!;
+ const internals = agent as unknown as {
+ resolveLocalAuthSelection(providerId: string | null | undefined, model: string): Promise<{ policy: 'isolated' | 'legacy-shared'; isCurrent(): boolean }>;
+ retireHostKey(key: string, reason: string, opts: { failIfActive: boolean; logPrefix: string }): Promise<void>;
+ };
+ let queryEntered = false;
+ let releaseQuery = () => {};
+ let releaseExit = () => {};
+ let rejectExit: (error: Error) => void = () => {};
+ const queryGate = new Promise<void>((resolve) => { releaseQuery = resolve; });
+ const exitGate = new Promise<void>((resolve, reject) => { releaseExit = resolve; rejectExit = reject; });
+ const retire = sourceHost.retire.bind(sourceHost);
+ const retireSpy = vi.spyOn(sourceHost, 'retire').mockImplementation(async (...args) => { await exitGate; return retire(...args); });
+ spies.push(retireSpy);
+ const originalResolve = internals.resolveLocalAuthSelection.bind(internals);
+ const queryHook = window.includes('resolve')
+ ? vi.spyOn(internals, 'resolveLocalAuthSelection').mockImplementationOnce(async (...args) => {
+ queryEntered = true; await queryGate; return originalResolve(...args);
+ })
+ : vi.spyOn(sourceHost, 'request').mockImplementationOnce(async (method, params, options) => {
+ expect(method).toBe('thread/loaded/list'); queryEntered = true; await queryGate;
+ return request.call(sourceHost, method, params, options);
+ });
+ spies.push(queryHook);
+ const target = { model: 'fixture-model', providerId: 'cprov-fixture', effort: 'high', fastMode: false };
+ const commit = vi.fn(async ({ newSdkSessionId }: { newSdkSessionId: string }) => commitCodexThreadTransfer(db, sourceRow as CodexThreadTransferSnapshot, { ...target, sdkSessionId: newSdkSessionId, effort: 'high' }));
+ const fork = vi.fn();
+ let settled = false;
+ const transfer = relinkCodexProviderThread({
+ readSource: async () => ({ ...sourceRow, model: sourceRow.model!, workingDir }),
+ needsFork: (threadId) => maker.requiresCodexThreadHostTransfer({ sessionId: 'source', threadId, model: target.model, providerId: target.providerId }),
+ fork, commit,
+ }, { sessionId: 'source', target });
+ void transfer.then(() => { settled = true; }, () => { settled = true; });
+ try {
+ await expect.poll(() => queryEntered).toBe(true);
+ const retirement = internals.retireHostKey('local', 'fixture retirement race', { failIfActive: false, logPrefix: 'fixture' });
+ await expect.poll(() => retireSpy.mock.calls.length).toBe(1);
+ releaseQuery();
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ expect(settled).toBe(false);
+ expect(commit).not.toHaveBeenCalled();
+ if (window.endsWith('failure')) {
+ rejectExit(new Error('fixture writer exit failed'));
+ await retirement;
+ await expect(transfer).rejects.toThrow('fixture writer exit failed');
+ expect(commit).not.toHaveBeenCalled();
+ } else {
+ releaseExit(); await retirement;
+ await expect(transfer).resolves.toMatchObject({ newSdkSessionId: sourceRow.sdkSessionId });
+ expect(commit).toHaveBeenCalledTimes(1);
+ const resumed = await maker.createSession({ id: 'source', agentKind: 'codex', model: target.model, providerId: target.providerId, workingDir, resumeSessionId: sourceRow.sdkSessionId! });
+ await send(resumed);
+ }
+ const persisted = sqlite.prepare('SELECT sdk_session_id, provider_id FROM sessions WHERE id = ?').get('source');
+ expect(persisted).toEqual({ sdk_session_id: sourceRow.sdkSessionId, provider_id: window.endsWith('failure') ? sourceRow.providerId : target.providerId });
+ expect(fork).not.toHaveBeenCalled();
+ expect((await storage.get('source'))!.sdkSessionId).toBe(sourceRow.sdkSessionId);
+ expect(siblingHost.getConnectionId()).toBe(connection);
+ await send(sibling);
+ } finally { releaseQuery(); releaseExit(); retireSpy.mockRestore(); await retire('fixture cleanup'); }
+ return;
+ }
+ if (window === 'transfer-busy') {
+ responseGate = new Promise<void>((resolve) => { releaseResponse = resolve; });
+ const inFlight = send(source);
+ await expect.poll(() => source.isTurnRunning()).toBe(true);
+ await expect.poll(() => calls.filter((call) => call === 'POST /provider/responses').length).toBe(2);
+ const relink = vi.fn(async () => {});
+ await expect(applyRuntimeSetModelChange({
+ maker, sessionId: 'source', model: 'fixture-model', providerId: 'cprov-fixture',
+ requiresCodexThreadRelink: true, relinkCodexThread: relink,
+ })).rejects.toThrow(/busy/);
+ expect(relink).not.toHaveBeenCalled();
+ expect(maker.getSession('source')).toBe(source);
+ expect(acceptedForks).toHaveLength(0);
+ await source.abort();
+ releaseResponse();
+ await inFlight;
+ expect(siblingHost.getConnectionId()).toBe(connection);
+ await send(sibling);
+ return;
+ }
+ for (const providerId of ['cprov-fixture', 'openai']) {
+ const sourceRow = (await db.drizzle.select({ id: sessions.id, sdkSessionId: sessions.sdkSessionId, model: sessions.model, providerId: sessions.providerId, effort: sessions.effort, fastMode: sessions.fastMode, updatedAt: sessions.updatedAt }).from(sessions)).find((row) => row.id === 'source')!;
+ const original = sourceRow.sdkSessionId!;
+ const rolloutPath = await (agent as unknown as { findRolloutPath(id: string): Promise<string> }).findRolloutPath(original);
+ const history = await readFile(rolloutPath, 'utf8');
+ const target = { sessionId: 'source', model: 'fixture-model', providerId, ...(reviewMode ? { reviewMode: true as const } : {}) };
+ const required = await maker.requiresCodexThreadHostTransfer({ ...target, threadId: original });
+ expect(required).toBe(true);
+ const before = acceptedForks.length;
+ const switching = applyRuntimeSetModelChange({
+ maker, sessionId: 'source', model: target.model, providerId,
+ requiresCodexThreadRelink: () => maker.requiresCodexThreadHostTransfer({ ...target, threadId: original }),
+ relinkCodexThread: async () => {
+ await relinkCodexProviderThread({
+ readSource: async () => ({ ...sourceRow, model: sourceRow.model!, workingDir }),
+ needsFork: (threadId) => maker.requiresCodexThreadHostTransfer({ ...target, threadId }),
+ fork: ({ sourceSdkSessionId }) => maker.forkSdkSession('codex', { sourceSdkSessionId: window === 'transfer-fork-failure' ? '00000000-0000-4000-8000-000000000000' : sourceSdkSessionId, model: target.model, providerId, workingDir, stripEncryptedReasoning: false, upToMessageId: undefined }),
+ commit: ({ newSdkSessionId }) => {
+ if (window === 'transfer-cas-failure') sqlite.exec("UPDATE sessions SET model = 'newer', updated_at = 2 WHERE id = 'source'");
+ return commitCodexThreadTransfer(db, sourceRow as CodexThreadTransferSnapshot, { sdkSessionId: newSdkSessionId, model: target.model, providerId, effort: 'high', fastMode: false });
+ },
+ }, { sessionId: 'source', target: { model: target.model, providerId, effort: 'high', fastMode: false } });
+ },
+ });
+ if (window === 'transfer-fork-failure' || window === 'transfer-cas-failure') {
+ await expect(switching).rejects.toThrow();
+ expect((await storage.get('source'))!.sdkSessionId).toBe(original);
+ if (window === 'transfer-cas-failure') expect((await storage.get('source'))!.model).toBe('newer');
+ expect(acceptedForks.length - before).toBeLessThanOrEqual(1);
+ expect([...hostMap.keys()].some((key) => key.startsWith('local-fork:'))).toBe(false);
+ expect(await readFile(rolloutPath, 'utf8')).toBe(history);
+ expect(siblingHost.getConnectionId()).toBe(connection);
+ await send(sibling);
+ return;
+ }
+ expect(await switching).toEqual({ status: 'applied', persistedRoute: true });
+ const replacement = (await storage.get('source'))!.sdkSessionId!;
+ // Review's dedicated host may exit at close, so no fork is needed then.
+ expect(acceptedForks.length - before).toBe(reviewMode ? 0 : 1);
+ if (!reviewMode) expect(replacement).not.toBe(original);
+ expect(await readFile(rolloutPath, 'utf8')).toBe(history);
+ expect([...hostMap.keys()].some((key) => key.startsWith('local-fork:'))).toBe(false);
+ const resumeOptions = { id: 'source', agentKind: 'codex' as const, providerId, model: target.model, workingDir, resumeSessionId: replacement, ...(reviewMode ? { reviewMode: true as const } : {}) };
+ if (window === 'transfer-resume-failure') {
+ rejectResumeRequest = true;
+ await expect(maker.createSession(resumeOptions)).rejects.toThrow(/provider/i);
+ expect((await storage.get('source'))!.sdkSessionId).toBe(replacement);
+ expect(acceptedForks.length - before).toBe(1);
+ }
+ source = await maker.createSession(resumeOptions);
+ expect(source.codexHostKey?.includes('external-auth')).toBe(providerId === 'cprov-fixture');
+ await send(source);
+ expect(hostMap.get('local')).toBe(siblingHost);
+ expect(siblingHost.getConnectionId()).toBe(connection);
+ await send(sibling);
+ }
+ } finally {
+ await maker.shutdown();
+ clearSessionProvider('source');
+ sqlite.close();
+ }
+ return;
+ }
+ if (lateWindow) {
+ // Start a shared sibling first; the target will initially select that host
+ // from an unknown route, then the real Desktop transaction installs API auth.
+ setCustomProviders([]);
+ const sibling = await agent.startSession({ sessionId: 'sibling', model: 'fixture-model', providerId: 'cprov-fixture', workingDir });
+ let resumeThreadId: string | undefined;
+ if (window === 'resume') {
+ const source = await agent.startSession({ sessionId: 'source', model: 'fixture-model', providerId: 'cprov-fixture', workingDir });
+ const done = (async () => { for await (const event of source.events()) { if (event.type === 'error') throw new Error(JSON.stringify(event)); if (event.type === 'done') return; } })();
+ await source.send({ type: 'user', content: 'persist fixture' }, { throwOnStartFailure: true });
+ await done;
+ await source.close();
+ // 0.153 retains source's writer after unsubscribe. Resume preparation
+ // starts with a released native child; the unrelated sibling stays live.
+ resumeThreadId = (await agent.forkSdkSession({ sourceSdkSessionId: source.id, upToMessageId: undefined, model: 'fixture-model', providerId: 'cprov-fixture', stripEncryptedReasoning: false })).newSdkSessionId;
+ }
+ const hostMap = (agent as unknown as { hosts: Map<string, AppServerHost> }).hosts;
+ const siblingHost = hostMap.get('local')!;
+ const siblingConnection = siblingHost.getConnectionId();
+ const accepted: Array<{ host: AppServerHost; method: string }> = [];
+ const request = AppServerHost.prototype.request;
+ spies.push(vi.spyOn(AppServerHost.prototype, 'request').mockImplementation(function (this: AppServerHost, method, params, opts) {
+ const result = request.call(this, method, params, { ...opts, beforeDispatch: () => {
+ opts?.beforeDispatch?.();
+ if (['thread/start', 'thread/resume'].includes(method)) accepted.push({ host: this, method });
+ } });
+ const pauseMethod = ['skills', 'restricted'].includes(window) ? 'skills/list'
+ : ['config', 'bot', 'local-skill'].includes(window) ? 'config/read' : undefined;
+ return pauseMethod === method ? result.then(async (response) => { await latePreparation?.(); return response; }) : result;
+ }));
+ let entered!: () => void;
+ let release!: () => void;
+ const waiting = new Promise<void>((resolve) => { entered = resolve; });
+ const gate = new Promise<void>((resolve) => { release = resolve; });
+ let once = false;
+ latePreparation = async () => { if (!once) { once = true; entered(); await gate; } };
+ const initialize = AppServerHost.prototype.ensureStartedWithTimeout;
+ if (window === 'initialize') spies.push(vi.spyOn(AppServerHost.prototype, 'ensureStartedWithTimeout').mockImplementation(async function (this: AppServerHost, ...args) {
+ const result = await initialize.apply(this, args);
+ await latePreparation?.();
+ return result;
+ }));
+ const rows = new Map<string, SessionMeta>();
+ const storage: SessionStorage = {
+ create: async (meta) => { const row = { ...meta, createdAt: 0, updatedAt: 0 }; rows.set(row.id, row); return row; },
+ get: async (id) => rows.get(id) ?? null,
+ list: async () => [...rows.values()],
+ update: async (id, patch) => { const row = { ...rows.get(id)!, ...patch }; rows.set(id, row); return row; },
+ compareAndClearSdkSessionId: async () => false,
+ delete: async (id) => { rows.delete(id); },
+ };
+ let startupGuard = false;
+ const failed = vi.fn();
+ const maker = new Maker({ agents: { codex: agent }, storage, logger, lifecycleHooks: {
+ onBeforeStart: async () => { startupGuard = true; },
+ onStartSucceeded: async () => { startupGuard = false; }, onStartFailed: failed,
+ } });
+ const target = maker.createSession({ id: 'late-target', agentKind: 'codex', providerId: 'cprov-fixture', model: 'fixture-model', workingDir,
+ ...(window === 'bot' ? { botRuntimeProfile: { botId: 'fixture', profileVersion: 1, skillPolicy: { mode: 'allowlist' as const, configured: [], catalog: [] }, toolsetPolicy: { mode: 'allowlist' as const, configured: [], catalog: [] }, mcpPolicy: { mode: 'allowlist' as const, configured: [], catalog: [] } } } : {}),
+ ...(reviewMode ? { reviewMode: true as const } : {}), ...(resumeThreadId ? { resumeSessionId: resumeThreadId } : {}),
+ });
+ try {
+ await waiting;
+ const finish = beginMutation();
+ setCustomProviders([buildUserProvider({ id: 'cprov-fixture', name: 'Fixture', runtimes: { codex: { baseUrl: `${endpoint}/provider`, wireProtocol: 'openai-responses', models: [{ id: 'fixture-model', name: 'Fixture' }] } } })]);
+ release();
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ expect(accepted).toEqual([]);
+ finish.commit(); finish();
+ const handle = await target;
+ expect(handle.codexHostKey).toContain('external-auth');
+ expect(startupGuard).toBe(false);
+ expect(failed).not.toHaveBeenCalled();
+ expect(accepted).toHaveLength(1);
+ expect(accepted[0].host).not.toBe(siblingHost);
+ if (reviewMode) expect(hostMap.has('local-review:late-target')).toBe(false);
+ expect(spawnConfigs.at(-1)).toBe('isolated');
+ // No forced retirement or cleanup of the live sibling on the shared host.
+ expect(hostMap.get('local')).toBe(siblingHost);
+ expect(siblingHost.getConnectionId()).toBe(siblingConnection);
+ await maker.closeSession('late-target');
+ await sibling.close();
+ } finally { release(); }
+ return;
+ }
+ const finish = beginMutation();
+ let guard: Awaited<ReturnType<typeof agent.beginLocalHostCredentialChange>> | undefined;
+ if (window === 'C') { guard = await agent.beginLocalHostCredentialChange(); await guard.finalize(); }
+ let settled = false;
+ const pending = agent.startSession({ sessionId: `fixture-${window}`, ...(reviewMode ? { reviewMode: true as const } : {}), providerId: 'cprov-fixture', model: 'fixture-model', workingDir })
+ .then((handle) => { settled = true; return handle; });
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ expect(settled).toBe(false);
+ expect(spawnConfigs).toEqual([]);
+ if (window === 'A') { guard = await agent.beginLocalHostCredentialChange(); await guard.finalize(); }
+ finish.commit(); finish();
+ const handle = await pending;
+ expect(handle.codexHostKey).toBe(reviewMode ? `local-review:fixture-${window}:external-auth` : 'local:external-auth');
+ expect(spawnConfigs.every((policy) => policy === 'isolated')).toBe(true);
+ const switchFinish = beginMutation();
+ let switchSettled = false;
+ const switching = Promise.resolve(handle.requiresModelSwitchRebuild!('fixture-model', { providerId: 'cprov-fixture' }))
+ .then((result) => { switchSettled = true; return result; });
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ expect(switchSettled).toBe(false);
+ switchFinish();
+ expect(await switching).toBe(false);
+ const cloudCallsBeforeCustom: string[] = [];
+ const events = (async () => {
+ for await (const event of handle.events()) {
+ if (event.type === 'error') throw new Error(JSON.stringify(event));
+ if (event.type === 'done') return;
+ }
+ })();
+ await handle.send({ type: 'user', content: 'return fixture complete' }, { throwOnStartFailure: true });
+ await expect.poll(() => calls.filter((call) => call === 'POST /provider/responses').length, { timeout: 10_000 }).toBe(1);
+ expect(calls.filter((call) => call.includes('/oauth/token') || call.includes('/config/bundle'))).toEqual(cloudCallsBeforeCustom);
+ if (authFixture) expect(await readFile(authPath, 'utf8')).toBe(authFixture);
+ await events;
+ await handle.close();
+ if (!reviewMode && window === 'B') {
+ const rolloutPath = await (agent as unknown as { findRolloutPath(id: string): Promise<string> }).findRolloutPath(handle.id);
+ const originalRollout = await readFile(rolloutPath, 'utf8');
+ await expect(agent.forkSdkSession({ sourceSdkSessionId: handle.id, upToMessageId: undefined, providerId: 'cprov-fixture', model: 'fixture-model', stripEncryptedReasoning: true })).rejects.toMatchObject({ name: 'CodexHistoryRecoveryRequiredError' });
+ expect(await readFile(rolloutPath, 'utf8')).toBe(originalRollout);
+ const acceptedForks: AppServerHost[] = [];
+ const forkRequest = AppServerHost.prototype.request;
+ spies.push(vi.spyOn(AppServerHost.prototype, 'request').mockImplementation(function (this: AppServerHost, method, params, opts) {
+ return forkRequest.call(this, method, params, { ...opts, beforeDispatch: () => {
+ opts?.beforeDispatch?.();
+ if (method === 'thread/fork') acceptedForks.push(this);
+ } });
+ }));
+ for (const delay of ['none', 'after-start']) {
+ const acceptedBefore = acceptedForks.length;
+ const delayPreparation = delay !== 'none';
+ let releasePreparation: () => void = () => {};
+ if (delayPreparation) preparationGate = new Promise<void>((resolve) => { releasePreparation = resolve; });
+ preparationEntered.mockClear();
+ let finishFork = delayPreparation ? undefined : beginMutation();
+ let forkSettled = false;
+ const forking = agent.forkSdkSession({ sourceSdkSessionId: handle.id, upToMessageId: undefined, providerId: 'cprov-fixture', model: 'fixture-model', stripEncryptedReasoning: false })
+ .then((result) => { forkSettled = true; return result; });
+ try {
+ if (delayPreparation) await expect.poll(() => preparationEntered.mock.calls.length).toBeGreaterThanOrEqual(1);
+ const pausedForkHost = delayPreparation
+ ? [...(agent as unknown as { hosts: Map<string, AppServerHost> }).hosts].find(([key]) => key.startsWith('local-fork:'))?.[1]
+ : undefined;
+ if (delayPreparation) expect(pausedForkHost).toBeDefined();
+ if (delayPreparation) finishFork = beginMutation();
+ releasePreparation();
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ expect(forkSettled).toBe(false);
+ finishFork?.();
+ const fork = await forking;
+ expect(fork.newSdkSessionId).not.toBe(handle.id);
+ expect(acceptedForks).toHaveLength(acceptedBefore + 1);
+ if (delayPreparation) expect(acceptedForks.at(-1)).not.toBe(pausedForkHost);
+ expect(await readFile(rolloutPath, 'utf8')).toBe(originalRollout);
+ expect(spawnConfigs.every((policy) => policy === 'isolated')).toBe(true);
+ } finally { releasePreparation(); finishFork?.(); }
+ }
+ }
+ if (!reviewMode && window === 'B') {
+ const finishCancel = beginMutation();
+ const cancelled = agent.startSession({ sessionId: 'cancelled-route', providerId: 'cprov-fixture', model: 'fixture-model', workingDir });
+ const rejection = expect(cancelled).rejects.toThrow(/cancelled/);
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ await agent.dispose();
+ await rejection;
+ finishCancel();
+ }
+ } finally {
+ releaseOAuth();
+ await coldStart;
+ releaseResponse();
+ for (const spy of spies) spy.mockRestore();
+ for (const release of releases) release();
+ setCustomProviders([]);
+ await agent.dispose();
+ await new Promise<void>((resolve) => server.close(() => resolve()));
+ await rm(root, { recursive: true, force: true });
+ }
+ }, 45_000);
+});
diff --git a/apps/desktop/src/main/maker-host/__tests__/codexSmartNamespace.integration.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexSmartNamespace.integration.test.ts
new file mode 100644
index 0000000000..2516bba47a
--- /dev/null
+++ b/apps/desktop/src/main/maker-host/__tests__/codexSmartNamespace.integration.test.ts
@@ -0,0 +1,167 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { describe, expect, it, vi } from 'vitest';
+import { buildUserProvider, type ProviderView } from '@cindy/model-providers';
+import { CodexAgent } from '../../../../../../packages/maker-core/src/agents/codex/index.js';
+import { AppServerHost } from '../../../../../../packages/maker-core/src/agents/codex/app-server/host.js';
+import type { AgentSessionHandle } from '../../../../../../packages/maker-core/src/agents/base-agent.js';
+import type { Logger } from '../../../../../../packages/maker-core/src/interfaces/logger.js';
+
+const fixture = vi.hoisted(() => ({ root: '' }));
+vi.mock('electron', () => ({ app: {
+ isPackaged: true, getPath: () => fixture.root, getAppPath: () => fixture.root,
+}, safeStorage: { isEncryptionAvailable: () => false } }));
+vi.mock('../../appCapabilities.js', () => ({ getAppCapabilities: () => ({ canUseCindyGateway: true }) }));
+
+const binary = process.env.CINDY_TEST_CODEX_BINARY;
+const logger: Logger = { trace() {}, debug() {}, info() {}, warn() {}, error() {}, fatal() {}, child: () => logger };
+
+// Explicit runtime opt-in; no installed binary discovery or real account access.
+describe.skipIf(!binary)('native smart child inherited Provider namespace', () => {
+ it('completes a selected child turn, then continues the parent with its original key', async () => {
+ fixture.root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-smart-native-'));
+ const home = path.join(fixture.root, 'home');
+ const codex = path.join(fixture.root, 'codex');
+ const work = path.join(fixture.root, 'work');
+ for (const dir of [home, codex, work]) fs.mkdirSync(dir);
+ const homeSpy = vi.spyOn(os, 'homedir').mockReturnValue(home);
+ const wires: Array<{ path: string; model: string; thread: string; parent: string; key: string; effort: unknown }> = [];
+ const registrations: Array<{ parentThreadId: string; childThreadId: string }> = [];
+ const completions = new Map<string, string>();
+ const issued = new Set<string>();
+ const failures: unknown[] = [];
+ let rootThread = '';
+ let agent: CodexAgent | undefined;
+ let handle: AgentSessionHandle | undefined;
+ const hostPrototype = AppServerHost.prototype as unknown as { routeNotification(method: string, params: unknown): void };
+ const notify = hostPrototype.routeNotification;
+ const notifications = vi.spyOn(hostPrototype, 'routeNotification').mockImplementation(function (this: AppServerHost, method, params) {
+ const event = params as { threadId?: string; turn?: { status?: string } };
+ if (method === 'turn/completed' && event.threadId) completions.set(event.threadId, event.turn?.status ?? 'unknown');
+ return notify.call(this, method, params);
+ });
+ const server = createServer(async (req, res) => {
+ try {
+ const chunks: Buffer[] = [];
+ for await (const chunk of req) chunks.push(Buffer.from(chunk));
+ if (!req.url?.endsWith('/responses')) { res.writeHead(404).end(); return; }
+ const body = JSON.parse(Buffer.concat(chunks).toString());
+ const thread = String(req.headers['thread-id'] ?? '');
+ const parent = String(req.headers['x-codex-parent-thread-id'] ?? '');
+ const child = parent !== '';
+ wires.push({ path: req.url, model: body.model, thread, parent,
+ key: String(req.headers.authorization), effort: body.reasoning?.effort });
+ expect(req.headers.authorization).toBe(`Bearer synthetic-${child ? 'cprov-child' : 'cprov-parent'}`);
+ expect(req.headers['chatgpt-account-id']).toBeUndefined();
+ expect(body.model).toBe(child ? 'gpt-6-astra' : 'api-parent');
+ if (child) expect(req.headers['x-openai-subagent']).toBe('collab_spawn');
+ // Use the actual tool schema emitted by this exact native runtime.
+ const namespace = body.tools?.find((tool: { type: string; name: string }) => tool.type === 'namespace' && tool.name === 'multi_agent_v1');
+ const spawn = namespace?.tools?.find((tool: { name: string }) => tool.name === 'spawn_agent');
+ let item: unknown;
+ if (!issued.has(thread) && thread === rootThread) {
+ expect(spawn).toBeTruthy();
+ if (thread === rootThread) expect(spawn.parameters.properties.model).toBeTruthy();
+ issued.add(thread);
+ item = { id: `fc-${wires.length}`, type: 'function_call', call_id: `call-${wires.length}`,
+ namespace: namespace.name, name: spawn.name, arguments: JSON.stringify({
+ message: 'Synthetic child task. Nested delegation is authorized.', fork_context: false,
+ ...(spawn.parameters.properties.model ? { model: 'gpt-6-astra' } : {}),
+ }) };
+ } else {
+ item = { id: `m-${wires.length}`, type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'synthetic complete' }] };
+ }
+ const id = `r-${wires.length}`;
+ const events = [{ type: 'response.created', response: { id } },
+ { type: 'response.output_item.done', item },
+ { type: 'response.completed', response: { id, status: 'completed', output: [item], usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } } }];
+ res.writeHead(200, { 'content-type': 'text/event-stream' }).end(events.map(event => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`).join(''));
+ } catch (error) { failures.push(error); res.writeHead(500).end(); }
+ });
+ await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+ const endpoint = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+ const catalog = await import('../active-catalog.js');
+ const routing = await import('../provider-route.js');
+ const proxy = await import('../codex-proxy-host.js');
+ const sessions = await import('../session-provider-store.js');
+ const { deriveCodexCustomProviderRoutes, buildCodexCustomProviderArgs } = await import('../codex-custom-provider-route.js');
+ const { selectCodexSmartSubagentCandidates } = await import('../codex-smart-subagent-routing.js');
+ try {
+ const providers = ['parent', 'child'].map(id => buildUserProvider({ id: `cprov-${id}`, name: id, runtimes: { codex: {
+ baseUrl: `${endpoint}/${id}`, wireProtocol: 'openai-responses', supportsImageGeneration: id === 'parent',
+ models: [{ id: id === 'parent' ? 'api-parent' : 'gpt-6-astra', name: id, contextWindow: 200_000, reasoningEfforts: ['high'] }],
+ } } }));
+ catalog.setCustomProviders(providers);
+ routing.setCustomProviderKeyReader(id => `synthetic-${id}`);
+ const candidates = selectCodexSmartSubagentCandidates(providers.map(provider => ({ ...provider, connected: true, agents: ['codex'] })) as ProviderView[],
+ { allowChatGptOAuth: true, oauthProviderId: 'cprov-parent' });
+ expect(candidates.some(candidate => candidate.providerId === 'cprov-child' && candidate.model.id === 'gpt-6-astra')).toBe(true);
+ expect(candidates.some(candidate => candidate.providerId === 'openai')).toBe(false);
+ const routes = deriveCodexCustomProviderRoutes(catalog.getActiveCatalog());
+ const parentRoute = routes.find(route => route.providerId === 'cprov-parent')!;
+ await proxy.ensureCodexCustomContextProxyReady('native-smart', 'provider-oauth', routes);
+ const proxyEndpoint = proxy.getCodexCustomContextProxyEndpoint('native-smart');
+ fs.writeFileSync(path.join(codex, 'config.toml'), [
+ 'model="api-parent"', `model_provider=${JSON.stringify(parentRoute.modelProviderId)}`,
+ 'check_for_update_on_startup=false', `chatgpt_base_url=${JSON.stringify(endpoint)}`,
+ '[analytics]', 'enabled=false', '[features]', 'plugins=false', 'remote_plugin=false',
+ '[agents]', 'max_depth=2', '[mcp_servers.cindy_memory]', 'command="/usr/bin/false"', 'enabled=false',
+ ].join('\n'));
+ const env = { HOME: home, USERPROFILE: home, CODEX_HOME: codex, TMPDIR: fixture.root,
+ OPENAI_API_KEY: '', CODEX_API_KEY: '', XDT_CODEX_API_KEY: 'synthetic-placeholder',
+ HTTP_PROXY: 'http://127.0.0.1:9', HTTPS_PROXY: 'http://127.0.0.1:9', ALL_PROXY: 'http://127.0.0.1:9', NO_PROXY: '127.0.0.1,localhost' };
+ sessions.setSessionProvider('native-smart-task', 'cprov-parent');
+ agent = new CodexAgent({ binaryPath: binary!, logger,
+ auth: { getState: async () => ({ authenticated: true }), triggerLogin: async () => ({ authenticated: true }),
+ logout: async () => {}, getAuthEnv: async () => env },
+ runtimeConfig: { behaviorFlags: env }, resolveCodexLocalAuthPolicy: routing.captureCodexLocalAuthPolicy,
+ prepareCodexExtraSpawnConfig: async () => ({
+ ...buildCodexCustomProviderArgs(proxyEndpoint, 'provider-oauth', routes), codexProxyActive: true,
+ extraArgs: [...buildCodexCustomProviderArgs(proxyEndpoint, 'provider-oauth', routes).extraArgs,
+ '-c', 'features.multi_agent_v2.expose_spawn_agent_model_overrides=true'],
+ smartSubagentRoutes: candidates.map(candidate => ({ providerId: candidate.providerId, catalogModel: candidate.model.id, reasoningEffort: 'high' })),
+ }),
+ registerCodexSystemPromptForThread: ({ sessionId, threadId, text, ...options }) => proxy.registerComposed(sessionId, threadId, text, options),
+ registerCodexChildThreadForParent: ({ parentThreadId, childThreadId }) => {
+ registrations.push({ parentThreadId, childThreadId }); proxy.registerChildThread(parentThreadId, childThreadId);
+ },
+ getCodexSubagentIdentity: ({ childThreadId }) => proxy.getObservedCodexSubagentIdentity(childThreadId),
+ });
+ handle = await agent.startSession({ sessionId: 'native-smart-task', providerId: 'cprov-parent', model: 'api-parent', workingDir: work });
+ rootThread = handle.id;
+ const send = async () => {
+ const done = (async () => { for await (const event of handle!.events()) {
+ if (event.type === 'error') throw new Error(JSON.stringify(event));
+ if (event.type === 'done') return;
+ } })();
+ await handle!.send({ type: 'user', content: 'synthetic delegation and completion' }, { throwOnStartFailure: true });
+ await done;
+ };
+ await send();
+ await vi.waitFor(() => {
+ expect(failures).toEqual([]);
+ expect(registrations).toHaveLength(1);
+ for (const { childThreadId } of registrations) expect(completions.get(childThreadId)).toBe('completed');
+ }, { timeout: 20_000 });
+ expect(registrations[0]?.parentThreadId).toBe(rootThread);
+ expect(wires.filter(wire => wire.parent)).toHaveLength(1);
+ expect(wires.filter(wire => wire.parent).every(wire => wire.path === '/child/responses' && wire.model === 'gpt-6-astra' && wire.effort === 'high')).toBe(true);
+ const before = wires.length;
+ await send();
+ expect(wires.slice(before)).toHaveLength(1);
+ expect(wires.at(-1)).toMatchObject({ thread: rootThread, path: '/parent/responses', model: 'api-parent' });
+ expect(failures).toEqual([]);
+ } finally {
+ await handle?.close(); await agent?.dispose();
+ proxy.unregister('native-smart-task'); sessions.clearSessionProvider('native-smart-task');
+ await proxy.releaseCodexCustomContextProxy('native-smart');
+ routing.setCustomProviderKeyReader(() => null); catalog.setCustomProviders([]);
+ notifications.mockRestore(); homeSpy.mockRestore();
+ server.closeAllConnections(); await new Promise<void>(resolve => server.close(() => resolve()));
+ fs.rmSync(fixture.root, { recursive: true, force: true });
+ }
+ }, 60_000);
+});
diff --git a/apps/desktop/src/main/maker-host/__tests__/providerRoute.test.ts b/apps/desktop/src/main/maker-host/__tests__/providerRoute.test.ts
index ac1c165cbc..5bab8d816a 100644
--- a/apps/desktop/src/main/maker-host/__tests__/providerRoute.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/providerRoute.test.ts
@@ -23,6 +23,8 @@ import {
getProviderRouteCredentialRevision,
getSessionRoutingDescriptor,
resolveSessionRoute,
+ resolveCodexLocalAuthPolicy,
+ captureCodexLocalAuthPolicy,
resolveSessionRouteDecision,
resolveFrozenProviderRouteDecision,
resolveImplicitLocalBridgeRoute,
@@ -93,6 +95,62 @@ afterEach(() => {
setCustomProviderHeaderReader(() => null);
});
+describe('Codex local auth policy', () => {
+ it('uses the actual custom route even without image generation capabilities', async () => {
+ setCustomProviders([buildUserProvider({
+ id: 'plain-key', name: 'Plain API',
+ runtimes: { codex: { baseUrl: 'https://example.invalid/v1', wireProtocol: 'openai-responses', models: [{ id: 'plain-model', name: 'Plain' }] } },
+ })]);
+ try {
+ expect(await resolveCodexLocalAuthPolicy('plain-key', 'plain-model')).toBe('isolated');
+ expect(await resolveCodexLocalAuthPolicy(undefined, 'plain-model')).toBe('isolated');
+ expect(await resolveCodexLocalAuthPolicy('missing-provider', 'plain-model')).toBe('legacy-shared');
+ } finally {
+ setCustomProviders([]);
+ }
+ });
+
+ it('waits through nested route mutations before selecting an API key policy', async () => {
+ setCustomProviders([buildUserProvider({
+ id: 'pending-key', name: 'Pending API',
+ runtimes: { codex: { baseUrl: 'https://example.invalid/v1', wireProtocol: 'openai-responses', models: [{ id: 'pending-model', name: 'Pending' }] } },
+ })]);
+ const finish = beginProviderRouteMutation('pending-key');
+ const nested = beginProviderRouteMutation('pending-key');
+ let settled = false;
+ const policy = resolveCodexLocalAuthPolicy('pending-key', 'pending-model').then((value) => { settled = true; return value; });
+ await Promise.resolve();
+ expect(settled).toBe(false);
+ finish.commit();
+ finish();
+ await Promise.resolve();
+ expect(settled).toBe(false);
+ nested();
+ await expect(policy).resolves.toBe('isolated');
+ });
+
+ it('invalidates a captured selection when a Desktop mutation starts, even without a core guard', async () => {
+ const before = await captureCodexLocalAuthPolicy('pending-key', 'pending-model');
+ expect(before.isCurrent()).toBe(true);
+ const finish = beginProviderRouteMutation('pending-key');
+ try {
+ expect(before.isCurrent()).toBe(false);
+ const abort = new AbortController();
+ const pending = captureCodexLocalAuthPolicy('pending-key', 'pending-model', abort.signal);
+ abort.abort(new Error('fixture cancelled'));
+ await expect(pending).rejects.toThrow('fixture cancelled');
+ } finally { finish(); }
+ expect(before.isCurrent()).toBe(false);
+ expect((await captureCodexLocalAuthPolicy('pending-key', 'pending-model')).isCurrent()).toBe(true);
+ });
+
+ it('isolates gateway routes while retaining official and third-party OAuth compatibility', async () => {
+ expect(await resolveCodexLocalAuthPolicy('openai', 'gpt-5.4')).toBe('legacy-shared');
+ expect(await resolveCodexLocalAuthPolicy('xd', 'gpt-5.4')).toBe('isolated');
+ expect(await resolveCodexLocalAuthPolicy('xai', 'xai/grok-4.3')).toBe('legacy-shared');
+ });
+});
+
describe('Pi per-model protocol routing', () => {
const provider = buildUserProvider({
id: 'pi-overrides',
diff --git a/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.ts b/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.ts
index c953f2fa5e..f2e227ecb7 100644
--- a/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.ts
+++ b/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.ts
@@ -40,7 +40,7 @@ import { getActiveCatalog } from './active-catalog.js';
import { outboundFetch } from './outbound-fetch.js';
import { getGrokAccessToken, peekGrokAccessToken } from './grok-oauth-login.js';
import { invalidateXaiBridgeAuth } from './xai-auth-invalidation-host.js';
-import { chatgptAccountIdFromIdToken, desktopCodexAuthAdapter } from './auth-adapters.js';
+import { chatgptAccountIdFromTokens, desktopCodexAuthAdapter } from './auth-adapters.js';
import { codexAccountHome, codexAccountState, invalidateCodexAccount, isOpenAiSubscriptionProviderId } from './codex-account-auth.js';
import {
bearerAccessTokenFromHeaders,
@@ -113,12 +113,6 @@ function jwtExpSec(token: string | undefined): number | null {
}
}
-/** tokens.account_id 优先;回落解 id_token(复用 auth-adapters 的 claim 解析,单点维护)。 */
-function accountIdFrom(tokens: NonNullable<CodexAuthFile['tokens']>): string | null {
- if (typeof tokens.account_id === 'string' && tokens.account_id.length > 0) return tokens.account_id;
- return typeof tokens.id_token === 'string' ? chatgptAccountIdFromIdToken(tokens.id_token) : null;
-}
-
function isExpired(accessToken: string | undefined): boolean {
const exp = jwtExpSec(accessToken);
if (exp == null) return false; // 解不出 exp → 不主动刷,靠上游 401 暴露
@@ -276,7 +270,7 @@ export async function getChatgptBridgeAuth(providerId = 'openai'): Promise<{ acc
const refreshed = await refreshIfNeeded(authPath, current);
throwIfOwnerBoundDispatchUnsafe(scopeAtStart);
if (!codexAccountState(providerId).authenticated || !refreshed.tokens?.access_token) throw new Error('OpenAI account changed during authentication');
- return { accessToken: refreshed.tokens.access_token, accountId: accountIdFrom(refreshed.tokens) };
+ return { accessToken: refreshed.tokens.access_token, accountId: chatgptAccountIdFromTokens(refreshed.tokens) };
}
const now = Date.now();
if (_authCache && now - _authCache.readAt < AUTH_CACHE_TTL_MS && !isExpired(_authCache.accessToken)) {
@@ -303,7 +297,7 @@ export async function getChatgptBridgeAuth(providerId = 'openai'): Promise<{ acc
obj = await refreshIfNeeded(authPath, obj);
throwIfOwnerBoundDispatchUnsafe(scopeAtStart);
const accessToken = obj.tokens?.access_token;
- const accountId = obj.tokens ? accountIdFrom(obj.tokens) : null;
+ const accountId = chatgptAccountIdFromTokens(obj.tokens);
if (!accessToken) {
_authCache = null;
throw new Error('codex auth.json 缺 access_token');
@@ -312,6 +306,27 @@ export async function getChatgptBridgeAuth(providerId = 'openai'): Promise<{ acc
return _authCache;
}
+/** A deferred child request must revalidate both credential and authorization at dispatch/retry. */
+export async function getChatgptBridgeAuthForDispatch(providerId = 'openai'): Promise<{
+ accessToken: string; accountId: string | null; canDispatch(): boolean;
+}> {
+ const ownerScope = activeOwnerScopeKey();
+ for (let attempt = 0; attempt < 2; attempt++) {
+ const auth = await getChatgptBridgeAuth(providerId);
+ throwIfOwnerBoundDispatchUnsafe(ownerScope);
+ const proof = desktopCodexAuthAdapter.captureOAuthDispatchProof(auth.accessToken, auth.accountId, providerId);
+ if (proof) return {
+ ...auth,
+ canDispatch: () => ownerScope === activeOwnerScopeKey()
+ && !isAppSessionBoundaryPending() && proof(),
+ };
+ // The existing cache can straddle native account replacement. Only a fresh,
+ // proven credential may produce a new decision; the old decision stays invalid.
+ clearChatgptBridgeCredentialCache();
+ }
+ throw new Error('OpenAI authorization changed while preparing the child request');
+}
+
/** codex(ChatGPT 订阅)provider 配置:chatgpt/ 前缀 → codex 后端,注入订阅 OAuth + codex 专属头。 */
function codexProviderConfig(providerId = 'openai'): BridgeProviderConfig {
return {
diff --git a/apps/desktop/src/main/maker-host/auth-adapters.ts b/apps/desktop/src/main/maker-host/auth-adapters.ts
index 78ecd90658..06df66b5b4 100644
--- a/apps/desktop/src/main/maker-host/auth-adapters.ts
+++ b/apps/desktop/src/main/maker-host/auth-adapters.ts
@@ -105,6 +105,7 @@ import {
bindNativeProviderAuth,
claimDetectedNativeProviderAuth,
isNativeProviderAuthBound,
+ captureNativeProviderAuthorizationGeneration,
isNativeProviderAuthRevoked,
isNativeProviderAuthSelfAuthorized,
isNativeProviderAuthSharedSystemCredential,
@@ -266,6 +267,14 @@ export function chatgptAccountIdFromIdToken(idToken: string): string | null {
return typeof sub === 'string' && sub.length > 0 ? sub : null;
}
+/** HTTP header identity only; workspace/recovery checks must keep the strict parser. */
+export function chatgptAccountIdFromTokens(
+ tokens: { account_id?: unknown; id_token?: unknown } | undefined,
+): string | null {
+ if (typeof tokens?.account_id === 'string' && tokens.account_id.length > 0) return tokens.account_id;
+ return typeof tokens?.id_token === 'string' ? chatgptAccountIdFromIdToken(tokens.id_token) : null;
+}
+
/**
* Codex 一次性轻任务(起会话标题 oneShot)直连 ChatGPT 后端所需的凭证。
* 读 xdt-maker 自管 codex-home 的 auth.json:`tokens.access_token` 作 Bearer、`account_id`
@@ -1710,6 +1719,39 @@ export class DesktopCodexAuthAdapter implements AuthAdapter {
return fingerprint ? JSON.stringify(fingerprint) : null;
}
+ /** Bind a host-owned request to the same credential and durable authorization as native Codex. */
+ captureOAuthDispatchProof(accessToken: string, accountId: string | null, providerId = 'openai'): (() => boolean) | null {
+ const independent = providerId !== 'openai';
+ const authenticated = () => independent
+ ? codexAccountState(providerId).authenticated : this.hasCodexOAuthLoginReadOnly();
+ if (!authenticated()) return null;
+ const home = independent ? codexAccountHome(providerId) : this.codexHome;
+ const authPath = path.join(home, 'auth.json');
+ const credential = () => {
+ const value = currentCodexCredentialGeneration(authPath);
+ return value ? JSON.stringify(value) : null;
+ };
+ // Independent accounts authorize against their existing account record;
+ // inherited OpenAI uses the native provider authorization record.
+ const authorization = () => independent
+ ? JSON.stringify(currentCodexCredentialGeneration(path.join(home, 'account.json')))
+ : captureNativeProviderAuthorizationGeneration('openai');
+ const credentialGeneration = credential();
+ const authorizationGeneration = authorization();
+ if (!credentialGeneration || !authorizationGeneration || authorizationGeneration === 'null') return null;
+ try {
+ const raw = fs.readFileSync(authPath, 'utf8');
+ const auth = JSON.parse(raw) as { tokens?: { access_token?: unknown; account_id?: unknown; id_token?: unknown } };
+ if (auth.tokens?.access_token !== accessToken || chatgptAccountIdFromTokens(auth.tokens) !== accountId) return null;
+ } catch {
+ return null;
+ }
+ const isCurrent = () => authenticated()
+ && credential() === credentialGeneration
+ && authorization() === authorizationGeneration;
+ return isCurrent() ? isCurrent : null;
+ }
+
/** Bracket one account-level RPC with compare-and-commit recovery confirmation. */
async verifyRecoveryWithAccountRpc<T>(read: () => Promise<T>): Promise<T> {
const proof = this.captureRecoveryVerificationProof();
diff --git a/apps/desktop/src/main/maker-host/codex-credential-switch.ts b/apps/desktop/src/main/maker-host/codex-credential-switch.ts
index a4511839ff..28ab8bf81d 100644
--- a/apps/desktop/src/main/maker-host/codex-credential-switch.ts
+++ b/apps/desktop/src/main/maker-host/codex-credential-switch.ts
@@ -71,6 +71,7 @@ function credentialFamilyFromAuthInjection(
}
interface LocalAgentSession {
+ codexHostKey?: string;
id: string;
agentKind: AgentKind;
remoteHostId?: string | null;
@@ -83,6 +84,8 @@ interface LocalCredentialModeSwitchMaker {
}
export interface PrepareLocalCodexCredentialModeSwitchInput {
+ /** Restrict arbitration to the host being replaced, preserving sibling hosts. */
+ hostKey?: string;
maker: LocalCredentialModeSwitchMaker;
isSessionInTurn?: (sessionId: string) => boolean;
signal?: AbortSignal;
@@ -447,7 +450,10 @@ export async function prepareLocalCodexCredentialModeSwitch(
input: PrepareLocalCodexCredentialModeSwitchInput,
): Promise<PrepareLocalCodexCredentialModeSwitchResult> {
throwIfCredentialSwitchAborted(input.signal);
- const localCodexSessions = input.maker.listActiveSessions().filter(isLocalCodexSession);
+ const localCodexSessions = input.maker.listActiveSessions().filter((session) =>
+ isLocalCodexSession(session) &&
+ (input.hostKey === undefined || (session.codexHostKey ?? 'local') === input.hostKey),
+ );
const busySessions = localCodexSessions.filter((session) =>
isSessionBusy(session, input.isSessionInTurn),
);
diff --git a/apps/desktop/src/main/maker-host/codex-custom-provider-route.ts b/apps/desktop/src/main/maker-host/codex-custom-provider-route.ts
index 9f66d2ccb4..c24c41fc40 100644
--- a/apps/desktop/src/main/maker-host/codex-custom-provider-route.ts
+++ b/apps/desktop/src/main/maker-host/codex-custom-provider-route.ts
@@ -55,6 +55,21 @@ export interface CodexCustomProviderRoute {
/** Routes actually frozen into the currently running local Codex Host. */
let appliedCustomProviderRoutes: readonly CodexCustomProviderRoute[] = [];
+const scopedAppliedCustomProviderRoutes = new Map<string, readonly CodexCustomProviderRoute[]>();
+
+/** Publish capability snapshots for independently owned Hosts without changing proxy dispatch. */
+export function registerCodexScopedCustomProviderRoutes(
+ scopeKey: string,
+ routes: readonly CodexCustomProviderRoute[],
+): () => void {
+ const snapshot = [...routes];
+ scopedAppliedCustomProviderRoutes.set(scopeKey, snapshot);
+ return () => {
+ if (scopedAppliedCustomProviderRoutes.get(scopeKey) === snapshot) {
+ scopedAppliedCustomProviderRoutes.delete(scopeKey);
+ }
+ };
+}
export function setCodexAppliedCustomProviderRoutes(
routes: readonly CodexCustomProviderRoute[],
@@ -73,7 +88,7 @@ export function hasCodexAppliedCustomProviderCapability(
capability: keyof CodexCustomProviderCapabilities,
): boolean {
const storedProviderId = storedCustomProviderId(providerId);
- return appliedCustomProviderRoutes.some(
+ return [...appliedCustomProviderRoutes, ...Array.from(scopedAppliedCustomProviderRoutes.values()).flat()].some(
(route) =>
storedCustomProviderId(route.providerId) === storedProviderId &&
route.capabilities[capability] === true,
@@ -269,12 +284,13 @@ export function crossesCodexAppliedCustomProviderIdentity(
}
const actual = input.currentThreadModelProviderId?.trim() || null;
+ const appliedRoutes = [...appliedCustomProviderRoutes, ...Array.from(scopedAppliedCustomProviderRoutes.values()).flat()];
const target = resolveCodexCustomProviderModelProviderId(
- appliedCustomProviderRoutes,
+ appliedRoutes,
input.targetProviderId?.trim() || null,
input.targetModel?.trim() || null,
);
- const actualIsAppliedCustomProviderIdentity = appliedCustomProviderRoutes.some(
+ const actualIsAppliedCustomProviderIdentity = appliedRoutes.some(
(route) => route.modelProviderId === actual,
);
const actualIsRetiredPrototypeIdentity =
diff --git a/apps/desktop/src/main/maker-host/codex-proxy-host.ts b/apps/desktop/src/main/maker-host/codex-proxy-host.ts
index 9fa4bbb9ff..b5cfbcbb34 100644
--- a/apps/desktop/src/main/maker-host/codex-proxy-host.ts
+++ b/apps/desktop/src/main/maker-host/codex-proxy-host.ts
@@ -104,6 +104,8 @@ import {
buildRouteDecision,
inferProviderIdForModel,
isHostInjectedAuthSession,
+ getProviderRouteCredentialRevision,
+ isProviderRouteMutationInProgress,
isUserProviderSession,
getUserProviderIdForSession,
readProviderOAuthToken,
@@ -163,6 +165,7 @@ const sessionToThreads = new Map<string, Set<string>>();
const threadToSession = new Map<string, string>();
const subagentRouteByParentThread = new Map<string, CodexSubagentRouteSnapshot>();
const subagentRouteByThread = new Map<string, CodexSubagentRouteSnapshot>();
+const subagentCredentialRevisions = new WeakMap<CodexSubagentRouteSnapshot, number>();
const smartSubagentRoutesByParentThread = new Map<
string,
ReadonlyMap<string, CodexSubagentRouteSnapshot>
@@ -365,6 +368,18 @@ export function getCodexProxyAuthInjection(): CodexProxyAuthInjection {
// gateway api key reader —— 由 host 注入(readClaudeApiKey), 避免 codex-proxy-host 直接 import
// auth-adapters(重模块, 会拖累单测加载 / 埋循环依赖)。proxy 给折扣 / api 流量换 gateway key 时调它。
+type CodexSubagentOAuth = {
+ accessToken: string;
+ accountId: string | null;
+ canDispatch(): boolean;
+};
+let readSubagentOAuth: ((providerId?: string) => Promise<CodexSubagentOAuth>) | undefined;
+
+/** Only an explicitly routed official child may request host-owned OAuth credentials. */
+export function setCodexSubagentOAuthReader(reader: (providerId?: string) => Promise<CodexSubagentOAuth>): void {
+ readSubagentOAuth = reader;
+}
+
let _readGatewayKey: () => string | null = () => null;
export function setCodexProxyGatewayKeyReader(fn: () => string | null): void {
_readGatewayKey = fn;
@@ -2747,8 +2762,61 @@ function resolveCodexCustomProviderRoutingDecision(
export function createModelRoutingTransform(
frozenAuthInjection?: CodexProxyAuthInjection,
frozenCustomProviderRoutes?: readonly CodexCustomProviderRoute[],
+ sourceHostAlive: () => boolean = () => true,
+ onCrossProviderChildAuthorized?: (ctx: RequestTransformCtx) => void,
): RoutingTransform {
return (body, ctx) => {
+ const inheritedPath = parseCodexCustomProviderPath(ctx.url);
+ if (inheritedPath.kind === 'route' && inheritedPath.pathKind === 'responses' && ctx.method === 'POST') {
+ // Select the first smart child before validating the inherited parent URL.
+ // Only registered collab lineage and this parent's frozen namespace can escape.
+ const sessionId = sessionIdFromHeaders(ctx.headers);
+ const parentRoute = customProviderRouteSnapshot(inheritedPath.routeId, frozenCustomProviderRoutes);
+ if (isCollabSpawnRequest(ctx.headers) && sessionId && parentRoute
+ && getSessionProvider(sessionId) === parentRoute.providerId) {
+ const transformed = createForcedSubagentRequestTransform()(body, ctx) ?? body;
+ const childRoute = subagentRouteFromHeaders(ctx.headers);
+ if (childRoute) {
+ const threadId = selectedThreadIdFromHeaders(ctx.headers);
+ const current = () => sourceHostAlive()
+ && threadToSession.get(threadId) === sessionId
+ && getSessionProvider(sessionId) === parentRoute.providerId
+ && subagentRouteByThread.get(threadId) === childRoute
+ && !isProviderRouteMutationInProgress(parentRoute.providerId)
+ && getProviderRouteCredentialRevision(parentRoute.providerId) === parentRoute.credentialRevision
+ && !isProviderRouteMutationInProgress(childRoute.providerId)
+ && getProviderRouteCredentialRevision(childRoute.providerId) === subagentCredentialRevisions.get(childRoute);
+ if (!current()) return unresolvedCollabSpawnRouteDecision();
+ const crossesProvider = childRoute.providerId !== parentRoute.providerId;
+ const decision = crossesProvider
+ ? createModelRoutingTransform(frozenAuthInjection, frozenCustomProviderRoutes, sourceHostAlive)(
+ body, { ...ctx, url: '/responses' },
+ )
+ : resolveCodexCustomProviderRoutingDecision(transformed, ctx, frozenCustomProviderRoutes);
+ return Promise.resolve(decision).then((resolved) => {
+ if (!resolved || !current()) return unresolvedCollabSpawnRouteDecision();
+ const useProviderTransforms = crossesProvider && Boolean(onCrossProviderChildAuthorized);
+ if (useProviderTransforms) onCrossProviderChildAuthorized!(ctx);
+ return {
+ ...(crossesProvider ? { pathOverride: '/responses' } : {}),
+ ...resolved,
+ dispatchGenerationValid: () => current() && (resolved.dispatchGenerationValid?.() ?? true),
+ // Cross-provider HTTP requests use the ordinary outbound chain exactly
+ // once. Never overwrite its wire model with the catalog identity afterward.
+ // Same-provider frozen namespaces keep their dedicated identity transform.
+ ...(useProviderTransforms ? {} : { transformRequestBody: async (raw, transformCtx) => {
+ const parsed: unknown = JSON.parse(raw.toString('utf8'));
+ const routed = createForcedSubagentRequestTransform()(parsed, ctx) ?? parsed;
+ const bytes = Buffer.from(JSON.stringify(routed));
+ return resolved.transformRequestBody
+ ? resolved.transformRequestBody(bytes, transformCtx)
+ : { body: bytes };
+ } }),
+ } satisfies RoutingDecision;
+ });
+ }
+ }
+ }
const customProviderRoute = resolveCodexCustomProviderRoutingDecision(
body,
ctx,
@@ -2817,7 +2885,26 @@ export function createModelRoutingTransform(
selectedRouting?.authStrategy === 'oauth-passthrough'
&& authInjection !== 'oauth-bearer'
) {
- return unresolvedCollabSpawnRouteDecision();
+ if (!readSubagentOAuth) {
+ return unresolvedCollabSpawnRouteDecision();
+ }
+ // The parent stays ephemeral. Fetch subscription credentials only when
+ // an explicit child route actually dispatches to the official backend.
+ const credentialRevision = getProviderRouteCredentialRevision(subagentRoute.providerId);
+ return readSubagentOAuth(subagentRoute.providerId).then((auth) => ({
+ upstreamOverride: CODEX_OAUTH_UPSTREAM,
+ headerOverride: {
+ authorization: `Bearer ${auth.accessToken}`,
+ ...(auth.accountId ? { 'chatgpt-account-id': auth.accountId } : {}),
+ },
+ ...(!auth.accountId ? { headerDelete: ['chatgpt-account-id'] } : {}),
+ dispatchGenerationValid: () => sourceHostAlive()
+ && !isProviderRouteMutationInProgress(subagentRoute.providerId)
+ && getProviderRouteCredentialRevision(subagentRoute.providerId) === credentialRevision
+ && threadToSession.get(threadId) === sessionId
+ && subagentRouteByThread.get(threadId) === subagentRoute
+ && auth.canDispatch(),
+ })).catch(() => unresolvedCollabSpawnRouteDecision());
}
if (selectedUsesLocalBridge) {
return resolveProviderRouteById(
@@ -3138,13 +3225,20 @@ export function withCodexUpstreamRecording(
};
}
-function createCodexProxyHandle(
+async function createCodexProxyHandle(
frozenAuthInjection?: CodexProxyAuthInjection,
frozenCustomProviderRoutes?: readonly CodexCustomProviderRoute[],
): Promise<ProxyHandle> {
const execAdapter = createCodexResponsesCompatibilityAdapter();
+ let alive = true;
const pricing: XaiRequestPricing = new Map();
- const route = createModelRoutingTransform(frozenAuthInjection, frozenCustomProviderRoutes);
+ // requestCtx and transformCtx share this request-owned headers object. A weak
+ // identity marker cannot be forged by header values or leak into the next request;
+ // it also needs no settlement bookkeeping for cancelled/local-handler requests.
+ const crossProviderRequests = new WeakSet<Readonly<Record<string, string>>>();
+ const route = createModelRoutingTransform(frozenAuthInjection, frozenCustomProviderRoutes, () => alive,
+ ctx => { crossProviderRequests.add(ctx.headers); });
+ const frozenReasoning = createCustomProviderReasoningTransform(frozenCustomProviderRoutes);
const routeWithUsageEncoding: RoutingTransform = (body, ctx) => {
const uncompressed = (decision: RoutingDecision | null): RoutingDecision | null => {
if (decision?.localHandler || !isXaiUpstream(decision?.upstreamOverride ?? '')
@@ -3156,7 +3250,7 @@ function createCodexProxyHandle(
const decision = route(body, ctx);
return decision instanceof Promise ? decision.then(uncompressed) : uncompressed(decision);
};
- return createAnthropicCompatProxy({
+ const handle = await createAnthropicCompatProxy({
// 默认上游 = gateway(含 /v1);普通模型 + oauth 由 routingTransform 覆盖到 ChatGPT。
upstream: () => buildCodexGatewayBaseUrl(),
transformRequest: createTransformRequestChain(frozenAuthInjection, execAdapter, pricing).map(
@@ -3164,15 +3258,19 @@ function createCodexProxyHandle(
// Namespaced Responses use a frozen Provider route. Preserve its native
// fields and model. The dedicated transform below reconciles effort
// against that same snapshot; ordinary session/catalog transforms stay out.
- if (transform === normalizeResponsesToolItemIds) return transform;
- const scoped: RequestTransform = (body, ctx) =>
- isCodexCustomProviderNamespacePath(ctx.url) ? null : transform(body, ctx);
+ const scoped: RequestTransform = (body, ctx) => {
+ if (crossProviderRequests.has(ctx.headers)) {
+ return transform(body, { ...ctx, url: '/responses' });
+ }
+ return isCodexCustomProviderNamespacePath(ctx.url) && transform !== normalizeResponsesToolItemIds
+ ? null : transform(body, ctx);
+ };
// Keep adapter rejection and request-state cleanup on ordinary routes.
scoped.errorMode = transform.errorMode;
scoped.onRequestSettled = transform.onRequestSettled;
return scoped;
},
- ).concat(createCustomProviderReasoningTransform(frozenCustomProviderRoutes)),
+ ).concat((body, ctx) => crossProviderRequests.has(ctx.headers) ? null : frozenReasoning(body, ctx)),
routeOpaqueRequestBody: (ctx) => isCodexCustomProviderNamespacePath(ctx.url),
bypassRequestTransforms: (_body, ctx) => {
const path = parseCodexCustomProviderPath(ctx.url);
@@ -3279,6 +3377,12 @@ function createCodexProxyHandle(
return CODEX_OAUTH_UPSTREAM;
},
});
+ const dispose = handle.dispose.bind(handle);
+ handle.dispose = async () => {
+ alive = false;
+ await dispose();
+ };
+ return handle;
}
/**
@@ -3535,11 +3639,9 @@ export function registerComposed(
const providerId = opts.subagentRoute?.providerId.trim();
const catalogModel = opts.subagentRoute?.catalogModel.trim();
if (providerId && catalogModel) {
- subagentRouteByParentThread.set(threadId, {
- providerId,
- catalogModel,
- reasoningEffort: opts.subagentRoute?.reasoningEffort ?? null,
- });
+ const route = { providerId, catalogModel, reasoningEffort: opts.subagentRoute?.reasoningEffort ?? null };
+ subagentCredentialRevisions.set(route, getProviderRouteCredentialRevision(providerId));
+ subagentRouteByParentThread.set(threadId, route);
} else {
subagentRouteByParentThread.delete(threadId);
}
@@ -3556,7 +3658,11 @@ export function registerComposed(
: {}),
});
}
- if (smartRoutes.size > 0) smartSubagentRoutesByParentThread.set(threadId, smartRoutes);
+ for (const route of smartRoutes.values()) {
+ subagentCredentialRevisions.set(route, getProviderRouteCredentialRevision(route.providerId));
+ }
+ // Legacy locked selection wins over optional smart candidates.
+ if (!providerId && smartRoutes.size > 0) smartSubagentRoutesByParentThread.set(threadId, smartRoutes);
else smartSubagentRoutesByParentThread.delete(threadId);
log.debug('registered codex prompt for thread', {
sessionId,
@@ -3629,6 +3735,10 @@ export function registerChildThread(parentThreadId: string, childThreadId: strin
return false;
}
+ // Notification and the first request can register the same child in either order.
+ // Never replace its resolved selection with a parent's route on the second call.
+ if (previousSessionId === sessionId && registry.get(childThreadId) !== undefined) return true;
+
const threads = sessionToThreads.get(sessionId) ?? new Set<string>();
threads.add(childThreadId);
sessionToThreads.set(sessionId, threads);
@@ -3637,14 +3747,14 @@ export function registerChildThread(parentThreadId: string, childThreadId: strin
const inheritedSubagentRoute =
subagentRouteByThread.get(parentThreadId)
?? subagentRouteByParentThread.get(parentThreadId);
- if (inheritedSubagentRoute) {
+ const inheritedSmartRoutes =
+ smartSubagentRoutesByThread.get(parentThreadId)
+ ?? smartSubagentRoutesByParentThread.get(parentThreadId);
+ if (inheritedSubagentRoute && !inheritedSmartRoutes) {
subagentRouteByThread.set(childThreadId, inheritedSubagentRoute);
} else {
subagentRouteByThread.delete(childThreadId);
}
- const inheritedSmartRoutes =
- smartSubagentRoutesByThread.get(parentThreadId)
- ?? smartSubagentRoutesByParentThread.get(parentThreadId);
if (inheritedSmartRoutes) smartSubagentRoutesByThread.set(childThreadId, inheritedSmartRoutes);
else smartSubagentRoutesByThread.delete(childThreadId);
log.debug('registered codex child thread route', {
diff --git a/apps/desktop/src/main/maker-host/index.ts b/apps/desktop/src/main/maker-host/index.ts
index de009ef972..825e25fda2 100644
--- a/apps/desktop/src/main/maker-host/index.ts
+++ b/apps/desktop/src/main/maker-host/index.ts
@@ -16,7 +16,7 @@ import { clearCodexAccountUsageSnapshot } from '../usageBroadcaster.js';
import { createMediaDownloadContext } from '../cindy-media/mediaDownloadApproval.js';
import { isCodexAccountProvider, codexAccountHome, setCodexAccountRetirement } from './codex-account-auth.js';
import { CodexThreadLocations } from './codex-thread-locations.js';
-import { getActiveAppSession } from '../appSessionState.js';
+import { getActiveAppSession, activeOwnerScopeKey, isAppSessionBoundaryPending } from '../appSessionState.js';
import { remoteCodexProvider } from './ssh-codex-models.js';
import { getActiveAuthRealm } from '../authManager.js';
import { getCustomProvider, updateCustomProviderIfUnchanged } from './custom-provider-store.js';
@@ -107,8 +107,6 @@ import { remoteInvoke } from '../device-link/index.js';
import { WorktreePool } from '../worktree/index.js';
import { getReadyBinaryPath, getCachedBinaryStatus } from '../agent-binaries/index.js';
import {
- activeOwnerScopeKey,
- isAppSessionBoundaryPending,
ownerScopedUserDataPath,
} from '../appSessionState.js';
import { getIOSSimulatorPluginAccessDecision } from '../cindy-brain/index.js';
@@ -135,7 +133,7 @@ import {
import { createToolResultImageDescriptor } from '../vision-bridge/tool-result-image-descriptor.js';
import * as blobStore from '../cindy-media/blobStore.js';
import { buildPiVisionBridgeEnv } from '../vision-bridge/pi-vision-bridge-env.js';
-import { resolveVisionBackendRoute, setVisionGatewayKeyReader } from './provider-route.js';
+import { captureCodexLocalAuthPolicy, resolveVisionBackendRoute, setVisionGatewayKeyReader } from './provider-route.js';
import { resolveSessionCcDebugFile, trackSessionCcDebugFile } from '../logger.js';
import { resetProviderModelAutoRefreshCooldowns } from './provider-model-auto-refresh.js';
import { getThinkingEnabledFromMemory } from './newMakerDefaultsCache.js';
@@ -183,7 +181,7 @@ import {
settleLocalPiPackageRuntimeSnapshot,
type PiPackageRuntimeInvalidationSnapshot,
} from './pi-package-runtime-invalidation.js';
-import { clearChatgptBridgeCredentialCache } from './anthropic-responses-bridge-host.js';
+import { clearChatgptBridgeCredentialCache, getChatgptBridgeAuthForDispatch } from './anthropic-responses-bridge-host.js';
import {
getDesktopSelectableCatalog,
getDesktopProviderService,
@@ -229,6 +227,7 @@ import {
releaseCodexCustomContextProxy,
setCodexProxyAuthInjection,
setCodexProxyGatewayKeyReader,
+ setCodexSubagentOAuthReader,
registerComposed as registerCodexProxyComposed,
registerChildThread as registerCodexProxyChildThread,
setCodexAppliedCustomProviderRoutes,
@@ -312,6 +311,7 @@ import {
import {
buildCodexCustomProviderArgs,
deriveCodexCustomProviderRoutes,
+ registerCodexScopedCustomProviderRoutes,
toCodexCustomProviderHostRoutes,
} from './codex-custom-provider-route.js';
import {
@@ -1458,7 +1458,7 @@ export function getMaker(): Maker {
const providerViews: ProviderView[] =
await getDesktopProviderService().listProviders({ allowSideEffects: false });
const candidates = selectCodexSmartSubagentCandidates(providerViews, {
- allowChatGptOAuth: ctx.credentialMode === 'oauth-bearer',
+ allowChatGptOAuth: ctx.credentialMode !== undefined,
oauthProviderId: ctx.providerId,
});
return codexSmartSubagentRoutingSignature(candidates, getActiveCatalogRevision())
@@ -1543,6 +1543,7 @@ export function getMaker(): Maker {
resolveDesktopModelContextProviderId(getDesktopSelectableCatalog(), 'codex', providerId, modelId), modelId),
resolveCodexContextWindowInfo: (modelId, config, reportedUsableWindow, codexHome) =>
readCodexContextWindowInfo({ codexHome: codexHome ?? getCodexHome(), binaryPath: codexPath, modelId, config, reportedUsableWindow }),
+ resolveCodexLocalAuthPolicy: captureCodexLocalAuthPolicy,
resolveCodexThreadContextWindow: (providerId, modelId) => {
const source = resolveDesktopModelContextProviderId(getDesktopSelectableCatalog(), 'codex', providerId, modelId);
const override = source ? readModelContextLimit('codex', source, modelId) : null;
@@ -1596,6 +1597,7 @@ export function getMaker(): Maker {
await prepareLocalCodexCredentialModeSwitch({
maker,
isSessionInTurn,
+ hostKey: ctx.hostKey,
fromMode: ctx.fromMode,
fromModeEffective: ctx.fromModeEffective,
toMode: ctx.toMode,
@@ -1625,17 +1627,18 @@ export function getMaker(): Maker {
const isControlPlane = ctx.hostPurpose === 'control-plane';
const isReview = ctx.hostPurpose === 'review';
const isCustomContext = ctx.hostPurpose === 'custom-context';
- const customContextHostKey = isCustomContext
- ? ctx.customContextHostKey?.trim() ?? ''
+ const needsContextScope = isCustomContext || ctx.localAuthPolicy === 'isolated';
+ const customContextHostKey = needsContextScope
+ ? (ctx.hostScopeKey ?? ctx.customContextHostKey)?.trim() ?? ''
: '';
- if (isCustomContext && !customContextHostKey) {
+ if (needsContextScope && !customContextHostKey) {
const error = new Error('custom-context Codex host is missing its runtime scope key');
(error as { codexSpawnConfigFatal?: boolean }).codexSpawnConfigFatal = true;
throw error;
}
const accountProxyKey = ctx.accountHostKey;
+ const usesScopedProxy = needsContextScope || !!accountProxyKey;
const scopedProxyKey = accountProxyKey || customContextHostKey;
- const usesScopedProxy = isCustomContext || !!accountProxyKey;
const usesIsolatedProxy = isControlPlane || isReview || usesScopedProxy;
const effectiveCodexHome = ctx.codexHome ?? getCodexHome();
let mcpExtraArgs: string[] = [];
@@ -1707,6 +1710,8 @@ export function getMaker(): Maker {
await broadcastCodexRuntimeRoute();
}
setCodexProxyGatewayKeyReader(readClaudeApiKey);
+ setCodexSubagentOAuthReader(getChatgptBridgeAuthForDispatch);
+
const customContextProviderRoutes = usesScopedProxy
? deriveCodexCustomProviderRoutes(getActiveCatalog())
: [];
@@ -1778,7 +1783,7 @@ export function getMaker(): Maker {
smartSubagentConfig = prepareCodexSmartSubagentConfig({
codexHome: effectiveCodexHome,
providerViews,
- allowChatGptOAuth: authInjection === 'oauth-bearer',
+ allowChatGptOAuth: true,
oauthProviderId: ctx.providerId,
catalogRevision: getActiveCatalogRevision(),
}) ?? undefined;
@@ -1830,6 +1835,9 @@ export function getMaker(): Maker {
storedSubagentModelSettings,
smartSubagentConfig,
);
+ const releaseScopedCapabilities = usesScopedProxy
+ ? registerCodexScopedCustomProviderRoutes(scopedProxyKey, codexCustomProviderRoutes)
+ : undefined;
return {
// 默认不碰 Codex 原生 Sol/Terra 调配。用户开启智能调配后才为这个本地
// app-server 冻结扩展目录与逐模型 Provider 路由。
@@ -1873,8 +1881,10 @@ export function getMaker(): Maker {
: {}),
...(usesScopedProxy
? {
- onHostRetired: () =>
- releaseCodexCustomContextProxy(scopedProxyKey),
+ onHostRetired: async () => {
+ releaseScopedCapabilities?.();
+ await releaseCodexCustomContextProxy(scopedProxyKey);
+ },
}
: {}),
};
@@ -2069,7 +2079,7 @@ export function getMaker(): Maker {
resetProviderModelAutoRefreshCooldowns('openai');
// auth 边界变了:「清单已在场」和「试过几次」都不再适用于下一个账号。
resetCodexModelBackfillState();
- await codexAgent.forceDisposeLocalHostForAuthChange('Codex desktop auth logout');
+ await codexAgent.forceDisposeLocalHostForAuthChange('Codex desktop auth logout', { preserveExternalAuth: true });
clearCodexProxyAuthInjection();
await broadcastCodexRuntimeRoute();
// 轮 27 HIGH-1:认证边界变更必须失效 PI MCP bridge —— 否则其 server
@@ -2088,7 +2098,7 @@ export function getMaker(): Maker {
// 必须在新 app-server 首次 model/list / Responses 请求之前清:bridge 的旧账号
// accessToken/accountId 有 30s 内存缓存,晚清会让新 host 短暂带旧账号凭证请求。
clearChatgptBridgeCredentialCache();
- await codexAgent.forceDisposeLocalHostForAuthChange('Codex desktop auth login');
+ await codexAgent.forceDisposeLocalHostForAuthChange('Codex desktop auth login', { preserveExternalAuth: true });
await broadcastCodexRuntimeRoute();
// 轮 27 HIGH-1:登录也是认证边界, 与登出对称失效 PI bridge。
invalidatePiEnvironment();
@@ -2128,6 +2138,7 @@ export function getMaker(): Maker {
// 只是这条路径从没让那个校验生效过。退役即补齐对称性,不需要在写入侧再加一层闸门。
await codexAgent.forceDisposeLocalHostForAuthChange(
`Codex credential invalidated: ${reason}`,
+ { preserveExternalAuth: true },
);
clearChatgptBridgeCredentialCache();
await refreshDiscoveredCodexModels(false);
@@ -3030,6 +3041,7 @@ export async function prepareCodexForCustomProviderHostChange(): Promise<void> {
const guard = _codexAgent
? await _codexAgent.beginLocalHostCredentialChange(
'Codex custom Provider route or credential changed',
+ { allLocalHosts: true, forceRetire: true },
)
: null;
let prepared = false;
diff --git a/apps/desktop/src/main/maker-host/nativeProviderAuthBinding.ts b/apps/desktop/src/main/maker-host/nativeProviderAuthBinding.ts
index 0c8dd94f7c..81f84a7e63 100644
--- a/apps/desktop/src/main/maker-host/nativeProviderAuthBinding.ts
+++ b/apps/desktop/src/main/maker-host/nativeProviderAuthBinding.ts
@@ -1,5 +1,5 @@
import { app } from 'electron';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
import fs from 'node:fs';
import { platform as hostPlatform } from 'node:os';
import path from 'node:path';
@@ -481,6 +481,21 @@ export function isNativeProviderAuthBound(provider: NativeProviderId): boolean {
return bindings[provider] === owner;
}
+/** Identity of the existing durable authorization record; no separate credential epoch. */
+export function captureNativeProviderAuthorizationGeneration(provider: NativeProviderId): string | null {
+ if (!isNativeProviderAuthBound(provider)) return null;
+ let fd: number | undefined;
+ try {
+ fd = fs.openSync(bindingPath(), 'r');
+ const stat = fs.fstatSync(fd, { bigint: true });
+ return `${stat.dev}:${stat.ino}:${stat.mtimeNs}:${createHash('sha256').update(fs.readFileSync(fd)).digest('hex')}`;
+ } catch {
+ return null;
+ } finally {
+ if (fd !== undefined) fs.closeSync(fd);
+ }
+}
+
/** Whether an explicit durable revocation currently suppresses this provider credential. */
export function isNativeProviderAuthRevoked(provider: NativeProviderId): boolean {
const read = readBindingsOrFail();
diff --git a/apps/desktop/src/main/maker-host/provider-route.ts b/apps/desktop/src/main/maker-host/provider-route.ts
index 064b522fb0..aa13dd952f 100644
--- a/apps/desktop/src/main/maker-host/provider-route.ts
+++ b/apps/desktop/src/main/maker-host/provider-route.ts
@@ -60,6 +60,7 @@ let customProviderHeaderReader: CustomProviderHeaderReader = () => null;
const providerRouteMutationCounts = new Map<string, number>();
const providerRouteCredentialRevisions = new Map<string, number>();
let nextProviderRouteCredentialRevision = 1;
+const providerRouteMutationWaiters = new Map<string, Set<() => void>>();
export type ProviderRouteMutationRelease = (() => void) & {
/** Publish the new non-sensitive route/capability/credential dispatch generation. */
@@ -96,7 +97,12 @@ export function beginProviderRouteMutation(providerId: string): ProviderRouteMut
if (finished) return;
finished = true;
const remaining = (providerRouteMutationCounts.get(providerId) ?? 1) - 1;
- if (remaining <= 0) providerRouteMutationCounts.delete(providerId);
+ if (remaining <= 0) {
+ providerRouteMutationCounts.delete(providerId);
+ const waiters = providerRouteMutationWaiters.get(providerId);
+ providerRouteMutationWaiters.delete(providerId);
+ for (const resolve of waiters ?? []) resolve();
+ }
else providerRouteMutationCounts.set(providerId, remaining);
}) as ProviderRouteMutationRelease;
finish.commit = () => {
@@ -625,6 +631,58 @@ export function getProviderRoutingDescriptor(
return routing;
}
+/** Choose process isolation from routing metadata without loading any credentials. */
+export async function captureCodexLocalAuthPolicy(
+ providerId: string | null | undefined,
+ modelId: string,
+ signal?: AbortSignal,
+): Promise<{ policy: 'isolated' | 'legacy-shared'; isCurrent: () => boolean }> {
+ // With an inferred source the transaction may temporarily remove the model
+ // from the catalog. Wait before inference, rather than freezing an unknown route.
+ while (true) {
+ signal?.throwIfAborted();
+ const pending = providerId
+ ? [runtimeCustomProviderId(providerId)].filter(isProviderRouteMutationInProgress)
+ : [...providerRouteMutationCounts.keys()];
+ if (pending.length === 0) break;
+ await Promise.all(pending.map((id) => new Promise<void>((resolve, reject) => {
+ const waiters = providerRouteMutationWaiters.get(id) ?? new Set<() => void>();
+ const done = () => {
+ signal?.removeEventListener('abort', cancel);
+ waiters.delete(done);
+ if (waiters.size === 0) providerRouteMutationWaiters.delete(id);
+ resolve();
+ };
+ const cancel = () => {
+ signal?.removeEventListener('abort', cancel);
+ waiters.delete(done);
+ if (waiters.size === 0) providerRouteMutationWaiters.delete(id);
+ reject(signal?.reason);
+ };
+ signal?.addEventListener('abort', cancel, { once: true });
+ waiters.add(done);
+ providerRouteMutationWaiters.set(id, waiters);
+ })));
+ }
+ const source = providerId ?? inferProviderIdForModel(modelId, 'codex');
+ const routing = getProviderRoutingDescriptor(source, 'codex', modelId);
+ // Keep legacy reuse for third-party OAuth and unknown routes. This
+ // is compatibility policy, not a claim that they need official Codex OAuth.
+ const revision = nextProviderRouteCredentialRevision;
+ return {
+ policy: routing?.authStrategy === 'api-key-header' || routing?.authStrategy === 'gateway-key'
+ ? 'isolated' : 'legacy-shared',
+ isCurrent: () => revision === nextProviderRouteCredentialRevision,
+ };
+}
+
+export async function resolveCodexLocalAuthPolicy(
+ providerId: string | null | undefined,
+ modelId: string,
+): Promise<'isolated' | 'legacy-shared'> {
+ return (await captureCodexLocalAuthPolicy(providerId, modelId)).policy;
+}
+
export interface ResolvedSessionRoute {
providerId: string;
providerSource: ProviderSource;
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/codexProviderThreadRelink.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/codexProviderThreadRelink.test.ts
index 85c81ad3eb..839a44cba3 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/codexProviderThreadRelink.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/codexProviderThreadRelink.test.ts
@@ -1,9 +1,13 @@
import { describe, expect, it, vi } from 'vitest';
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import type { DbClient } from '../../localDb/client/DbClient.js';
import {
decideCodexProviderThreadRelink,
isXdOpenAiCodexProviderTransition,
relinkCodexProviderThread,
+ commitCodexThreadTransfer,
} from '../codexProviderThreadRelink.js';
const source = {
@@ -43,7 +47,47 @@ describe('isXdOpenAiCodexProviderTransition', () => {
});
});
+describe('Codex writer transfer SQLite commit', () => {
+ it.each(['unchanged', 'sdk', 'model', 'provider', 'archived', 'revision'])('preserves task identity and rejects stale %s snapshots', async (change) => {
+ const sqlite = new Database(':memory:');
+ sqlite.exec(`CREATE TABLE sessions (id TEXT PRIMARY KEY, status TEXT, agent_kind TEXT, remote_host_id TEXT, sdk_session_id TEXT, model TEXT, provider_id TEXT, effort TEXT, fast_mode INTEGER, updated_at INTEGER);
+ INSERT INTO sessions VALUES ('S', 'active', 'codex', NULL, 'old', 'model', 'openai', 'high', 0, 1);
+ INSERT INTO sessions VALUES ('U', 'active', 'codex', NULL, 'unrelated', 'model', 'openai', 'high', 0, 1);
+ CREATE TABLE messages (session_id TEXT, content TEXT);
+ INSERT INTO messages VALUES ('S', 'retained history');`);
+ const db = { drizzle: drizzle(sqlite) } as unknown as Pick<DbClient, 'drizzle'>;
+ const snapshot = { id: 'S', sdkSessionId: 'old', model: 'model', providerId: 'openai', effort: 'high' as const, fastMode: false, updatedAt: 1 };
+ try {
+ const updates: Record<string, string> = {
+ sdk: "sdk_session_id = 'newer'", model: "model = 'newer'", provider: "provider_id = 'newer'",
+ archived: "status = 'archived'", revision: 'updated_at = 2',
+ };
+ if (updates[change]) sqlite.exec(`UPDATE sessions SET ${updates[change]} WHERE id = 'S'`);
+ const before = sqlite.prepare('SELECT * FROM sessions ORDER BY id').all();
+ expect(await commitCodexThreadTransfer(db, snapshot, { sdkSessionId: 'child', model: 'target', providerId: 'cprov-fixture', fastMode: true })).toBe(change === 'unchanged');
+ const after = sqlite.prepare('SELECT * FROM sessions ORDER BY id').all();
+ expect(after[1]).toEqual(before[1]);
+ if (change !== 'unchanged') expect(after).toEqual(before);
+ else expect(after[0]).toMatchObject({ id: 'S', sdk_session_id: 'child', model: 'target', provider_id: 'cprov-fixture', effort: 'high', fast_mode: 1 });
+ expect(sqlite.prepare('SELECT * FROM messages').all()).toEqual([{ session_id: 'S', content: 'retained history' }]);
+ } finally { sqlite.close(); }
+ });
+});
+
describe('relinkCodexProviderThread', () => {
+ it('keeps the native thread when closing the source has already released its writer', async () => {
+ const fork = vi.fn();
+ const commit = vi.fn(async () => true);
+ const result = await relinkCodexProviderThread({
+ readSource: async () => source,
+ needsFork: async () => false,
+ fork, commit,
+ }, { sessionId: 'released', target });
+ expect(fork).not.toHaveBeenCalled();
+ expect(result?.newSdkSessionId).toBe(source.sdkSessionId);
+ expect(commit).toHaveBeenCalledWith(expect.objectContaining({ newSdkSessionId: source.sdkSessionId, target }));
+ });
+
it.each([
{
name: 'implicit XD to OpenAI',
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/runtimeSetModelCodexRelink.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/runtimeSetModelCodexRelink.test.ts
index 2d19f3f330..1f656f4001 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/runtimeSetModelCodexRelink.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/runtimeSetModelCodexRelink.test.ts
@@ -52,6 +52,63 @@ const routeCases = ['codex/gpt-5.6-sol', 'codex/gpt-5.6-luna'].flatMap((discount
},
]);
+describe('Codex writer decision freshness', () => {
+ it.each(['released', 'moved', 'failed'])('rechecks the writer after close: %s', async (state) => {
+ const sessionId = rememberSession(`post-close-${state}`);
+ setSessionProvider(sessionId, 'cprov-source');
+ let closed = false;
+ const relink = vi.fn(async () => {});
+ const restore = vi.fn();
+ const pending = { model: 'earlier', providerId: 'cprov-earlier' };
+ const maker: RuntimeSetModelMaker = {
+ getSession: () => ({ agentKind: 'codex', model: 'source', setModel: vi.fn(), requiresModelSwitchRebuild: async () => true }),
+ listActiveSessions: () => [{ id: sessionId, agentKind: 'codex', isTurnRunning: () => false }],
+ closeSession: async () => { closed = true; },
+ };
+ const result = applyRuntimeSetModelChange({ maker, sessionId, model: 'target', providerId: 'cprov-target',
+ requiresCodexThreadRelink: async () => {
+ if (closed && state === 'failed') throw new Error('writer lookup failed');
+ return closed && state === 'moved';
+ }, relinkCodexThread: relink, getPendingCredentialSwitch: () => pending,
+ clearPendingCredentialSwitch: vi.fn(), registerPendingCredentialSwitch: restore });
+ if (state === 'failed') {
+ await expect(result).rejects.toThrow('writer lookup failed');
+ expect(restore).toHaveBeenCalledWith(sessionId, pending);
+ expect(getSessionProvider(sessionId)).toBe('cprov-source');
+ } else {
+ await expect(result).resolves.toEqual(state === 'moved' ? { status: 'applied', persistedRoute: true } : { status: 'applied' });
+ }
+ expect(relink).toHaveBeenCalledTimes(state === 'moved' ? 1 : 0);
+ });
+
+ it.each([false, true])('rechecks after asynchronous model inspection with busy=%s', async (busy) => {
+ const sessionId = rememberSession('route-changes-during-inspection');
+ setSessionProvider(sessionId, 'cprov-source');
+ let requiresTransfer = false;
+ const relink = vi.fn(async () => {});
+ const closeSession = vi.fn(async () => {});
+ const registerPendingCredentialSwitch = vi.fn();
+ const maker: RuntimeSetModelMaker = {
+ getSession: () => ({ agentKind: 'codex', model: 'source', remoteHostId: null,
+ setModel: vi.fn(), requiresModelSwitchRebuild: async () => { requiresTransfer = true; return true; } }),
+ listActiveSessions: () => [{ id: sessionId, agentKind: 'codex', isTurnRunning: () => busy }],
+ closeSession,
+ };
+ const switching = applyRuntimeSetModelChange({ maker, sessionId, model: 'target', providerId: 'cprov-target',
+ requiresCodexThreadRelink: async () => requiresTransfer, relinkCodexThread: relink, registerPendingCredentialSwitch });
+ if (busy) {
+ await expect(switching).rejects.toThrow(/busy/);
+ expect(closeSession).not.toHaveBeenCalled();
+ expect(relink).not.toHaveBeenCalled();
+ expect(registerPendingCredentialSwitch).not.toHaveBeenCalled();
+ } else {
+ await expect(switching).resolves.toEqual({ status: 'applied', persistedRoute: true });
+ expect(closeSession).toHaveBeenCalledOnce();
+ expect(relink).toHaveBeenCalledOnce();
+ }
+ });
+});
+
describe.each(routeCases)('Codex route: $sourceModel → $targetModel', (route) => {
const { sourceProvider, sourceModel, targetProvider, targetModel } = route;
it('closes, relinks, then publishes the idle target route', async () => {
diff --git a/apps/desktop/src/main/maker-ipc/codexProviderThreadRelink.ts b/apps/desktop/src/main/maker-ipc/codexProviderThreadRelink.ts
index 52b20f81f1..fbc2a54236 100644
--- a/apps/desktop/src/main/maker-ipc/codexProviderThreadRelink.ts
+++ b/apps/desktop/src/main/maker-ipc/codexProviderThreadRelink.ts
@@ -1,11 +1,40 @@
/**
- * Rebuild a local Codex native thread before crossing the XD/OpenAI credential boundary.
+ * Transfer a local Codex native writer before changing hosts.
*
- * Fork authentication belongs to the source thread. The replacement thread id and the
+ * The caller selects the native fork route. The replacement thread id and the
* complete target runtime route are then committed by one caller-provided CAS.
*/
import { resolveAgentCredentialMode } from '@cindy/maker-core';
+import { and, eq, isNull } from 'drizzle-orm';
+import type { DbClient } from '../localDb/client/DbClient.js';
+import { sessions } from '../localDb/schema.js';
+
+export type CodexThreadTransferSnapshot = Pick<typeof sessions.$inferSelect,
+ 'id' | 'sdkSessionId' | 'model' | 'providerId' | 'effort' | 'fastMode' | 'updatedAt'>;
+
+export function codexThreadTransferSourcePredicate(source: CodexThreadTransferSnapshot) {
+ return and(
+ eq(sessions.id, source.id), eq(sessions.status, 'active'),
+ eq(sessions.agentKind, 'codex'), isNull(sessions.remoteHostId),
+ source.sdkSessionId === null ? isNull(sessions.sdkSessionId) : eq(sessions.sdkSessionId, source.sdkSessionId),
+ source.model === null ? isNull(sessions.model) : eq(sessions.model, source.model),
+ source.providerId === null ? isNull(sessions.providerId) : eq(sessions.providerId, source.providerId),
+ eq(sessions.effort, source.effort), eq(sessions.fastMode, source.fastMode),
+ eq(sessions.updatedAt, source.updatedAt),
+ );
+}
+
+export async function commitCodexThreadTransfer(
+ db: Pick<DbClient, 'drizzle'>,
+ source: CodexThreadTransferSnapshot,
+ target: Pick<typeof sessions.$inferSelect, 'sdkSessionId' | 'model' | 'providerId' | 'fastMode'> &
+ { effort?: typeof sessions.$inferSelect.effort; contextWindow?: number },
+): Promise<boolean> {
+ const result = await db.drizzle.update(sessions).set({ ...target, updatedAt: Date.now() })
+ .where(codexThreadTransferSourcePredicate(source)).run();
+ return result.changes === 1;
+}
export interface CodexProviderThreadRoute {
model: string;
@@ -21,6 +50,7 @@ export interface CodexProviderThreadRelinkSource extends CodexProviderThreadRout
export interface CodexProviderThreadRelinkDeps {
readSource(sessionId: string): Promise<CodexProviderThreadRelinkSource | null>;
+ needsFork?(threadId: string): Promise<boolean>;
fork(input: {
sourceSdkSessionId: string;
sourceModel: string;
@@ -79,7 +109,9 @@ export async function relinkCodexProviderThread(
if (!source?.sdkSessionId) return null;
const sourceWithThread = { ...source, sdkSessionId: source.sdkSessionId };
- const forked = await deps.fork({
+ const forked = deps.needsFork && !await deps.needsFork(sourceWithThread.sdkSessionId)
+ ? { newSdkSessionId: sourceWithThread.sdkSessionId }
+ : await deps.fork({
sourceSdkSessionId: sourceWithThread.sdkSessionId,
sourceModel: sourceWithThread.model,
sourceProviderId: sourceWithThread.providerId,
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 11013458b5..126f652659 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -980,6 +980,7 @@ import {
closeRejectedRuntimeAndRestoreControlStores,
isRemoteModelSwitchRouteChangeError,
} from './runtimeSetModel.js';
+import { codexThreadTransferSourcePredicate, commitCodexThreadTransfer, relinkCodexProviderThread } from './codexProviderThreadRelink.js';
import {
codexCustomProviderConfigSignature,
hasCodexAppliedCustomProviderCapability,
@@ -16180,6 +16181,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
providerId: sessions.providerId,
effort: sessions.effort,
fastMode: sessions.fastMode,
+ updatedAt: sessions.updatedAt,
workingDir: sessions.workingDir,
contextTokens: sessions.contextTokens,
contextWindow: sessions.contextWindow,
@@ -16927,6 +16929,103 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
});
};
try {
+ const transferDb = getCurrentDbClientSnapshot();
+ const transferOwner = captureDataOwnerBroadcastScope();
+ // A completed, owner-fenced window handoff may have already replaced the
+ // native thread during this same locked selection.
+ const transferStatus = modelWindowRebuilt && runtimeAgentKind === 'codex'
+ ? (await transferDb!.client.drizzle.select().from(sessions).where(eq(sessions.id, sessionId)).limit(1))[0]
+ : runtimeStatus;
+ assertRuntimeOwnerCurrent();
+ if (!transferStatus || transferStatus.status !== 'active') {
+ throw new Error('Codex writer transfer task changed');
+ }
+ const transferMeta = runtimeAgentKind === 'codex' ? await maker.getSessionMeta(sessionId) : null;
+ const transferTarget = {
+ sessionId,
+ model,
+ providerId: targetRouteProviderId,
+ remoteHostId: transferStatus.remoteHostId ?? undefined,
+ ...(transferMeta?.reviewMode ? { reviewMode: true as const } : {}),
+ };
+ const canTransferThread = routeExplicit && runtimeAgentKind === 'codex' &&
+ !transferStatus.remoteHostId && !!transferStatus.sdkSessionId;
+ const assertTransferOwner = () => {
+ assertRuntimeOwnerCurrent();
+ if (!transferDb || !isDataOwnerBroadcastScopeCurrent(transferOwner) ||
+ getCurrentDbClientSnapshot()?.clientEpoch !== transferDb.clientEpoch) {
+ throw new Error('Codex writer transfer owner changed');
+ }
+ };
+ const relinkCodexThread = async () => {
+ assertTransferOwner();
+ const sourceSnapshot = { ...transferStatus, id: sessionId };
+ const sourcePredicate = codexThreadTransferSourcePredicate(sourceSnapshot);
+ const transferred = await relinkCodexProviderThread({
+ readSource: async () => {
+ assertTransferOwner();
+ const [source] = await transferDb!.client.drizzle.select({ id: sessions.id })
+ .from(sessions).where(sourcePredicate).limit(1);
+ assertTransferOwner();
+ if (!source) throw new Error('Codex writer transfer source changed');
+ return {
+ sdkSessionId: transferStatus.sdkSessionId,
+ model: transferStatus.model ?? currentRuntimeModel ?? model,
+ providerId: transferStatus.providerId,
+ effort: transferStatus.effort,
+ fastMode: transferStatus.fastMode,
+ workingDir: transferStatus.workingDir,
+ };
+ },
+ needsFork: async (threadId) => {
+ assertTransferOwner();
+ return maker.requiresCodexThreadHostTransfer({ ...transferTarget, threadId });
+ },
+ fork: async ({ sourceSdkSessionId, workingDir }) => {
+ assertTransferOwner();
+ // Native fork never rewrites source history. The core owns the one-shot
+ // writer exit barrier; use the destination route, even if old auth expired.
+ return maker.forkSdkSession('codex', {
+ sourceSdkSessionId, workingDir, model,
+ upToMessageId: undefined,
+ providerId: targetRouteProviderId,
+ stripEncryptedReasoning: false,
+ });
+ },
+ commit: async ({ newSdkSessionId, target }) => {
+ assertTransferOwner();
+ return commitCodexThreadTransfer(transferDb!.client, sourceSnapshot, {
+ sdkSessionId: newSdkSessionId,
+ model: target.model,
+ providerId: target.providerId,
+ ...(target.effort !== null && isSupportedRuntimeEffort(target.effort) ? { effort: target.effort } : {}),
+ fastMode: target.fastMode,
+ ...(modelWindowRebuilt && targetContextWindow ? { contextWindow: targetContextWindow } : {}),
+ });
+ },
+ }, {
+ sessionId,
+ target: {
+ model, providerId: targetRouteProviderId,
+ effort: atomicSelection ? atomicSelection.effort : transferStatus.effort,
+ fastMode: atomicSelection ? atomicSelection.fastMode : transferStatus.fastMode,
+ },
+ });
+ assertTransferOwner();
+ if (transferred) {
+ try {
+ broadcastSessionPatched(sessionId, {
+ sdkSessionId: transferred.newSdkSessionId,
+ model, providerId: targetRouteProviderId,
+ }, transferOwner);
+ } catch (error) {
+ log.warn('Codex writer transfer projection failed after commit', {
+ sessionId, error: error instanceof Error ? error.message : String(error),
+ });
+ }
+ }
+ };
+ assertRuntimeOwnerCurrent();
const result = routeExplicit
? await applyRuntimeSetModelChange({
maker,
@@ -16934,6 +17033,12 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
sessionId,
model,
providerId: effectiveProviderId,
+ ...(canTransferThread ? {
+ requiresCodexThreadRelink: () => maker.requiresCodexThreadHostTransfer({
+ ...transferTarget, threadId: transferStatus.sdkSessionId!,
+ }),
+ relinkCodexThread,
+ } : {}),
...(atomicSelection?.effort
? {
effort: atomicSelection.effort as
@@ -16980,6 +17085,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
if (supersededByOwnerBoundary()) {
return { deferred: false, superseded: true };
}
+ if (result.persistedRoute === true && isDeviceLinkInvoke()) {
+ markRemoteSettingPersistedInsideHandler(response);
+ }
const piSessionAfterRouteChange = maker.getSession(sessionId);
if (
runtimeAgentKind === 'pi' &&
diff --git a/apps/desktop/src/main/maker-ipc/runtimeSetModel.ts b/apps/desktop/src/main/maker-ipc/runtimeSetModel.ts
index 30d6a3a05c..19909ff729 100644
--- a/apps/desktop/src/main/maker-ipc/runtimeSetModel.ts
+++ b/apps/desktop/src/main/maker-ipc/runtimeSetModel.ts
@@ -105,10 +105,10 @@ export interface ApplyRuntimeSetModelChangeInput {
*/
codexAuthInjection?: CodexProxyAuthInjection | null;
/**
- * The host has proved that this local Codex selection crosses the explicit XD/OpenAI
- * credential boundary and has a persisted native thread to rebuild.
+ * The host found a native writer in another local process. Closing the business
+ * handle may retain that writer, so verify release or relink before publishing.
*/
- requiresCodexThreadRelink?: boolean;
+ requiresCodexThreadRelink?: boolean | (() => Promise<boolean>);
/** Closes over the captured Profile DB and atomically commits thread + full target route. */
relinkCodexThread?: () => Promise<void>;
logger?: RuntimeSetModelLogger;
@@ -193,10 +193,8 @@ export async function applyRuntimeSetModelChange(
codexAuthInjection: input.codexAuthInjection,
})
: false;
- const requiresCodexThreadRelink = input.requiresCodexThreadRelink === true;
- if (requiresCodexThreadRelink && !input.relinkCodexThread) {
- throw new Error(`Codex provider thread relink is required for session ${sessionId}`);
- }
+ let requiresCodexThreadRelink = typeof input.requiresCodexThreadRelink === 'function'
+ ? await input.requiresCodexThreadRelink() : input.requiresCodexThreadRelink === true;
const modelSwitchRequiresRebuild =
sess &&
input.forceSessionRebuild !== true &&
@@ -209,6 +207,12 @@ export async function applyRuntimeSetModelChange(
modelSwitchRequiresRebuild ||
credentialModeRequiresRebuild
);
+ if (shouldCloseSession && typeof input.requiresCodexThreadRelink === 'function') {
+ requiresCodexThreadRelink = await input.requiresCodexThreadRelink();
+ }
+ if (requiresCodexThreadRelink && !input.relinkCodexThread) {
+ throw new Error(`Codex provider thread relink is required for session ${sessionId}`);
+ }
let selfBusyMemo: boolean | undefined;
const isSelfBusy = (): boolean => {
if (selfBusyMemo !== undefined) return selfBusyMemo;
@@ -340,16 +344,20 @@ export async function applyRuntimeSetModelChange(
}
throw err;
}
- if (requiresCodexThreadRelink) {
- try {
- await input.relinkCodexThread?.();
- } catch (error) {
- // A failed history transfer must not discard an earlier accepted pending route.
- if (clearedPending && input.registerPendingCredentialSwitch) {
- await input.registerPendingCredentialSwitch(sessionId, clearedPending);
- }
- throw error;
+ let relinkAfterClose = false;
+ try {
+ relinkAfterClose = requiresCodexThreadRelink ||
+ (typeof input.requiresCodexThreadRelink === 'function' && await input.requiresCodexThreadRelink());
+ if (relinkAfterClose) {
+ if (!input.relinkCodexThread) throw new Error(`Codex provider thread relink is required for session ${sessionId}`);
+ await input.relinkCodexThread();
+ }
+ } catch (error) {
+ // A failed history transfer must not discard an earlier accepted pending route.
+ if (clearedPending && input.registerPendingCredentialSwitch) {
+ await input.registerPendingCredentialSwitch(sessionId, clearedPending);
}
+ throw error;
}
if (providerId !== undefined) setSessionProvider(sessionId, nextProviderId);
// close + route 都落定后再唤醒队列:排队消息按新凭证形态 lazy-create 派发。
@@ -369,7 +377,7 @@ export async function applyRuntimeSetModelChange(
fromModel: sess.model,
toModel: model,
});
- return requiresCodexThreadRelink
+ return relinkAfterClose && input.relinkCodexThread
? { status: 'applied', persistedRoute: true }
: { status: 'applied' };
}
diff --git a/docs/dev-rules/maker-core-and-agent-behavior.md b/docs/dev-rules/maker-core-and-agent-behavior.md
index ec9c67a180..6221cb5250 100644
--- a/docs/dev-rules/maker-core-and-agent-behavior.md
+++ b/docs/dev-rules/maker-core-and-agent-behavior.md
@@ -99,8 +99,12 @@ Claude Code/Codex/Pi 的强制换窗线
与 Pi 的日常默认值也设为 90%,对齐 Codex 口径,但用户已有显式 override 继续生效。命中
`danger`/`overflow` 的本机会话先走同一套 `context_rebuild` bounded handoff,再落目标
route,不能 resume 旧原生窗口。
-Codex 跨凭证时先按目标来源 resume 同一个原生线程,不因 `ordinal` / `history_base` 或来源
-变化而 fork、改写历史或交接。本地恢复与分叉必须同时固定该线程的原生历史根
+Codex 跨凭证优先保留同一个原生线程;仅当目标需要另一个 host、旧 host 仍持有原生 writer
+时,关闭该任务的业务 handle 后使用不剥离历史的原生 fork,并等待一次性 fork host 退出,
+再以任务 owner 与旧 SDK/路由版本为条件原子保存新 SDK thread 和目标路由。任务 ID 与
+消息历史不变,无关任务与 host 不退出;旧 writer 已释放则不 fork。`ordinal` /
+`history_base` 本身不能成为改写历史的理由。
+本地恢复与分叉必须同时固定该线程的原生历史根
(`CODEX_HOME`,含 `sessions` / `archived_sessions`)和数据库根(`sqlite_home`);
仅固定 SQLite 不足以恢复分页祖先,原生按不可变 rollout ID 在历史根内查找祖先。
凭证、代理路由和模型目录仍按本轮选中账号准备,不能把历史根写回全局账号配置。
diff --git a/packages/maker-core/src/agents/base-agent.ts b/packages/maker-core/src/agents/base-agent.ts
index 6362afcf4f..75763c41d1 100644
--- a/packages/maker-core/src/agents/base-agent.ts
+++ b/packages/maker-core/src/agents/base-agent.ts
@@ -87,6 +87,12 @@ import type { AutoReviewDelegate, AutoReviewDecision, AutoReviewRequest } from '
import type { ReviewableAction } from './shared/auto-review.js';
import type { ClaudeSubagentModelAccessResult } from './claude-code/subagent-model-access.js';
+export type CodexLocalAuthPolicyResolution = 'isolated' | 'legacy-shared' | {
+ policy: 'isolated' | 'legacy-shared';
+ /** Synchronous check of the host routing transaction that produced this policy. */
+ isCurrent: () => boolean;
+};
+
export interface AgentCapabilityAdditions {
/** Extra models exposed by the host for this agent. Existing built-in ids are ignored. */
availableModels?: readonly ModelDescriptor[];
@@ -462,6 +468,8 @@ export interface LocalAgentProcessRegistration {
}
export interface CodexLocalCredentialModeSwitchContext {
+ /** Exact local host being replaced; omitted by legacy hosts. */
+ hostKey?: string;
fromMode?: AgentCredentialMode;
/**
* 当前 host 的归一化生效形态(createHost 时按 auth fallback 推出并登记)。
@@ -969,6 +977,13 @@ export interface AgentDeps {
modelId: string,
) => number | null;
+ /** Local disk-auth policy, independent of the actual Provider credential mode. */
+ resolveCodexLocalAuthPolicy?: (
+ providerId: string | null | undefined,
+ modelId: string,
+ signal?: AbortSignal,
+ ) => CodexLocalAuthPolicyResolution | Promise<CodexLocalAuthPolicyResolution>;
+
/**
* Per-model requested context window (user override first, explicit provider default second).
* A one-session native catalog permits this window without changing sibling routes.
@@ -1010,6 +1025,9 @@ export interface AgentDeps {
accountHostKey?: string;
remoteHostId?: string;
credentialMode?: AgentCredentialMode;
+ /** Frozen disk OAuth policy; independent of the actual Provider credential. */
+ localAuthPolicy?: 'isolated' | 'legacy-shared';
+ hostScopeKey?: string;
/** Original session request when the shared host was upgraded to a credential superset. */
requestedCredentialMode?: AgentCredentialMode;
/** Marks app-server work that must not share the normal local task host. */
@@ -2154,6 +2172,8 @@ export interface AgentSessionHandle {
): () => void;
/** Codex-only: 当前会话绑定的 app-server host 是否经 loopback proxy 出口。 */
readonly codexProxyActive?: boolean;
+ /** Local runtime identity, never serialized to the remote wire protocol. */
+ readonly codexHostKey?: string;
/**
* Codex-only: thread/start 或 thread/resume 响应确认的实际 model provider。
* 这是 thread 级冻结身份,不随 thread/settings/update 的模型切换改变。
@@ -2616,6 +2636,13 @@ export abstract class BaseAgent {
return this.throwNotSupported('forkSdkSession', 'sdk-missing');
}
+ async requiresCodexThreadHostTransfer(
+ opts: Pick<StartSessionOptions, 'sessionId' | 'model' | 'providerId' | 'reviewMode' | 'remoteHostId'> & { threadId: string },
+ ): Promise<boolean> {
+ void opts;
+ return false;
+ }
+
// ── Auth 透传到 deps.auth ────────────────────────────────────────────────
// Maker 不直接访问 agent.deps (protected), 通过这层 thin façade 暴露给 host
// 的 maker:auth:* IPC handler。BaseAgent 把"agent 的鉴权"作为一等公民,
diff --git a/packages/maker-core/src/agents/codex/app-server/client.ts b/packages/maker-core/src/agents/codex/app-server/client.ts
index 16b02fc30f..7db23ca29a 100644
--- a/packages/maker-core/src/agents/codex/app-server/client.ts
+++ b/packages/maker-core/src/agents/codex/app-server/client.ts
@@ -313,6 +313,11 @@ export class AppServerClient {
return response;
}
+ /** Only local transports can prove this pre-protocol failure and process exit. */
+ nativeSqliteInitializationFailed(): boolean {
+ return !this.initialized && this.transport?.nativeSqliteInitializationFailed?.() === true;
+ }
+
/**
* close() 是幂等的; reason 仅用于 reject pending requests 的错误消息。
* - reject 所有挂起 promise
diff --git a/packages/maker-core/src/agents/codex/app-server/external-auth.native.test.ts b/packages/maker-core/src/agents/codex/app-server/external-auth.native.test.ts
index f1f525bc20..756e57bb90 100644
--- a/packages/maker-core/src/agents/codex/app-server/external-auth.native.test.ts
+++ b/packages/maker-core/src/agents/codex/app-server/external-auth.native.test.ts
@@ -30,7 +30,7 @@ function fakeTokens(account: string, revision = 'initial') {
return { accessToken: `test.${payload}.not-a-signature`, chatgptAccountId: account, chatgptPlanType: 'pro' };
}
-async function fixture(archivedParent = false, testRefresh = false) {
+async function fixture(archivedParent = false, testRefresh = false, revokedRefresh = false, generic401 = false) {
const root = await fs.mkdtemp(path.join(os.tmpdir(), 'cindy-codex-history-contract-'));
roots.push(root);
const historyHome = path.join(root, 'history-a');
@@ -38,11 +38,17 @@ async function fixture(archivedParent = false, testRefresh = false) {
await fs.mkdir(credentialHome);
const wireRequests: Array<{ authorization: string | undefined; account: string | string[] | undefined }> = [];
const refreshRequests: unknown[] = [];
+ const discoveryRequests: Array<string | string[] | undefined> = [];
const server = createServer(async (request, response) => {
if (request.method === 'POST' && request.url === '/oauth/token') {
let body = '';
for await (const chunk of request) body += chunk;
refreshRequests.push(JSON.parse(body));
+ if (revokedRefresh) {
+ response.writeHead(400, { 'content-type': 'application/json' });
+ response.end(JSON.stringify({ error: { code: 'refresh_token_invalidated', message: 'Synthetic refresh credential revoked' } }));
+ return;
+ }
const token = fakeTokens('account-b', 'refreshed').accessToken;
response.writeHead(200, { 'content-type': 'application/json' });
response.end(JSON.stringify({ id_token: token, access_token: token, refresh_token: 'fixture-refresh-b2' }));
@@ -51,9 +57,9 @@ async function fixture(archivedParent = false, testRefresh = false) {
if (request.method === 'POST' && request.url?.endsWith('/responses')) {
wireRequests.push({ authorization: request.headers.authorization, account: request.headers['chatgpt-account-id'] });
request.resume();
- if (testRefresh && wireRequests.length === 1) {
+ if (testRefresh && (request.headers.authorization !== `Bearer ${fakeTokens('account-b', 'refreshed').accessToken}` || request.headers['chatgpt-account-id'] !== 'account-b')) {
response.writeHead(401, { 'content-type': 'application/json' });
- response.end(JSON.stringify({ error: { message: 'expired fixture credential' } }));
+ response.end(JSON.stringify({ error: { ...(generic401 ? {} : { code: 'token_expired' }), message: 'Provided authentication token is expired.' } }));
return;
}
response.writeHead(200, { 'content-type': 'text/event-stream' });
@@ -63,6 +69,14 @@ async function fixture(archivedParent = false, testRefresh = false) {
} })}\n\n`);
return;
}
+ if (request.method === 'GET' && request.url?.endsWith('/accounts/check')) {
+ discoveryRequests.push(request.headers['chatgpt-account-id']);
+ response.writeHead(200, { 'content-type': 'application/json' });
+ response.end(JSON.stringify({ accounts: ['account-a', 'account-b'].map(id => ({
+ id, workspace_backend_origin: `https://127.0.0.1:${(server.address() as import('node:net').AddressInfo).port}`, account_routing_override: 'NO_CONSTRAINT',
+ })), default_account_id: 'account-a' }));
+ return;
+ }
response.setHeader('content-type', 'application/json');
response.end(JSON.stringify({ models: [] }));
});
@@ -108,6 +122,7 @@ async function fixture(archivedParent = false, testRefresh = false) {
'-c', `sqlite_home=${JSON.stringify(historyHome)}`,
'-c', `cli_auth_credentials_store="${managed ? 'file' : 'ephemeral'}"`, '-c', 'model_provider="probe"',
'-c', 'model_providers.probe.name="Probe"', '-c', `model_providers.probe.base_url=${JSON.stringify(baseUrl)}`,
+ '-c', 'model_providers.probe.stream_max_retries=0', '-c', 'model_providers.probe.request_max_retries=0',
'-c', 'model_providers.probe.wire_api="responses"', '-c', `model_providers.probe.requires_openai_auth=${Boolean(account)}`,
'-c', `chatgpt_base_url=${JSON.stringify(baseUrl)}`],
}),
@@ -121,13 +136,13 @@ async function fixture(archivedParent = false, testRefresh = false) {
approvalPolicy: 'never', sandbox: 'read-only',
}, { timeoutMs: 15_000 });
}
- async function assertOriginals(managed = false) {
- expect(await fs.readFile(parent.file, 'utf8')).toBe(parent.text);
+ async function assertOriginals(managed = false, expectedParent = parent.text) {
+ expect(await fs.readFile(parent.file, 'utf8')).toBe(expectedParent);
expect(await fs.readFile(path.join(historyHome, 'auth.json'), 'utf8')).toBe(oldAuth);
expect((await fs.stat(path.join(historyHome, 'auth.json'))).mtimeMs).toBe(authStat.mtimeMs);
if (!managed) await expect(fs.stat(path.join(credentialHome, 'auth.json'))).rejects.toMatchObject({ code: 'ENOENT' });
}
- return { root, historyHome, credentialHome, parent, child, rollout, host, resume, assertOriginals, wireRequests, refreshRequests };
+ return { root, historyHome, credentialHome, parent, child, rollout, host, resume, assertOriginals, wireRequests, refreshRequests, discoveryRequests };
}
describe.skipIf(!binaryPath)('real Codex history/account isolation contract', () => {
@@ -147,6 +162,8 @@ describe.skipIf(!binaryPath)('real Codex history/account isolation contract', ()
const host = f.host(f.historyHome, account);
await expect(f.resume(host, grandchild)).resolves.toMatchObject({ thread: { id: grandchild.id } });
const status = await host.request('account/read', { refreshToken: false });
+ expect(f.discoveryRequests.at(-1)).toBe(account);
+ expect(status).toMatchObject({ workspaceRouting: { chatgptAccountId: account } });
expect(status).toMatchObject({ account: { type: 'chatgpt', email: `${account}@example.invalid`, planType: 'pro' } });
await host.shutdown('simulate transport replacement');
await expect(f.resume(host, grandchild)).resolves.toMatchObject({ thread: { id: grandchild.id } });
@@ -223,15 +240,35 @@ describe.skipIf(!binaryPath)('real Codex history/account isolation contract', ()
const original = f.host(f.historyHome, 'account-a');
await f.resume(original, f.parent);
await original.retire();
+ // 0.156 persists a thread-owned settings snapshot on resume. Original
+ // indexed bytes and ordinals stay unchanged; only this exact native record
+ // is permitted. The rejected cross-home fork must not append anything else.
+ const resumedHistory = await fs.readFile(f.parent.file, 'utf8');
+ expect(resumedHistory.startsWith(f.parent.text)).toBe(true);
+ const appended = resumedHistory.slice(f.parent.text.length).trim().split('\n').map(line => JSON.parse(line));
+ expect(appended).toEqual([{
+ timestamp: expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/), ordinal: 2, type: 'event_msg',
+ payload: { type: 'thread_settings_applied', thread_id: f.parent.id, thread_settings: {
+ model: 'gpt-6-astra', model_provider_id: 'probe', approval_policy: 'never', approvals_reviewer: 'user',
+ permission_profile: { type: 'managed', file_system: { type: 'restricted', entries: [
+ { path: { type: 'special', value: { kind: 'root' } }, access: 'read' },
+ ] }, network: 'restricted' },
+ cwd: f.root, runtime_workspace_roots: [f.root],
+ collaboration_mode: { mode: 'default', settings: { model: 'gpt-6-astra', reasoning_effort: null, developer_instructions: null } },
+ disabled_plugin_ids: [],
+ } },
+ }]);
const oldForkHost = f.host(f.credentialHome, 'account-b');
await expect(oldForkHost.request('thread/fork', {
threadId: f.parent.id, path: f.parent.file, cwd: f.root, model: 'gpt-6-astra',
}, { timeoutMs: 15_000 })).rejects.toThrow('must be in Codex home directory');
- await f.assertOriginals();
+ await f.assertOriginals(false, resumedHistory);
}, 30_000);
- it('refreshes managed credentials on disk after a native 401 even before natural expiry', async () => {
- const f = await fixture(false, true);
+ it.each(['expired', 'generic', 'revoked'])('handles managed credentials after a native 401 before expiry (%s)', async (mode) => {
+ const revoked = mode === 'revoked';
+ const f = await fixture(false, true, revoked, mode === 'generic');
+ const readerCalls: boolean[] = [];
const authPath = path.join(f.credentialHome, 'auth.json');
const initial = fakeTokens('account-b').accessToken;
// A freshly written managed login must still force-refresh after a rejected request.
@@ -240,6 +277,7 @@ describe.skipIf(!binaryPath)('real Codex history/account isolation contract', ()
last_refresh: new Date().toISOString() }));
const accountHost = f.host(f.credentialHome, 'account-b', true);
const host = f.host(f.historyHome, 'account-b', false, { readTokens: async refresh => {
+ readerCalls.push(refresh);
if (refresh) await accountHost.request('account/read', { refreshToken: true }, { timeoutMs: 8_000 });
const credentials = JSON.parse(await fs.readFile(authPath, 'utf8'));
return { accessToken: credentials.tokens.access_token, chatgptAccountId: credentials.tokens.account_id };
@@ -250,7 +288,14 @@ describe.skipIf(!binaryPath)('real Codex history/account isolation contract', ()
const subscription = host.subscribeThread(f.child.id, { turnCompleted: completed });
try {
await host.request('turn/start', { threadId: f.child.id, input: [{ type: 'text', text: 'fixture request' }] }, { timeoutMs: 15_000 });
- await expect(completion).resolves.toMatchObject({ turn: { status: 'completed' } });
+ await expect(completion).resolves.toMatchObject({ turn: { status: revoked ? 'failed' : 'completed' } });
+ expect(readerCalls).toEqual([false, true]);
+ if (revoked) {
+ expect(f.wireRequests).toEqual([{ authorization: `Bearer ${initial}`, account: 'account-b' }]);
+ expect(f.refreshRequests).toHaveLength(1);
+ await f.assertOriginals(true);
+ return;
+ }
expect(f.wireRequests).toEqual([
{ authorization: `Bearer ${fakeTokens('account-b').accessToken}`, account: 'account-b' },
{ authorization: `Bearer ${fakeTokens('account-b', 'refreshed').accessToken}`, account: 'account-b' },
diff --git a/packages/maker-core/src/agents/codex/app-server/host.test.ts b/packages/maker-core/src/agents/codex/app-server/host.test.ts
index 191e802237..c287f27e01 100644
--- a/packages/maker-core/src/agents/codex/app-server/host.test.ts
+++ b/packages/maker-core/src/agents/codex/app-server/host.test.ts
@@ -1,6 +1,6 @@
import { describe, expect, it, vi } from 'vitest';
-import { AppServerHost } from './host.js';
+import { AppServerHost, CodexNativeInitializationStoppedError } from './host.js';
import type { Logger } from '../../../interfaces/logger.js';
import type { Transport, LineHandler, StderrHandler, CloseHandler } from './transport.js';
@@ -153,6 +153,40 @@ class NotificationTransport implements Transport {
}
}
+describe('concrete writer candidate proof', () => {
+ it.each(['request', 'notification', 'subscription'])('retains %s evidence until confirmed process exit', async (source) => {
+ const transports: NotificationTransport[] = [];
+ const host = new AppServerHost({ createTransport: () => {
+ const transport = new NotificationTransport(); transports.push(transport); return transport;
+ }, logger, clientInfo: { name: 'test', version: '0' } });
+ try {
+ await host.ensureStarted();
+ expect(host.writerCandidate).toBeNull();
+ await host.request('thread/loaded/list');
+ expect(host.writerCandidate).toBeNull();
+ if (source === 'request') await host.request('thread/resume', { threadId: 'source' });
+ if (source === 'notification') transports[0].emit({ method: 'thread/started', params: { thread: { id: 'source' } } });
+ if (source === 'subscription') host.subscribeThread('source', {});
+ const proof = host.writerCandidate;
+ expect(proof).not.toBeNull();
+ const close = vi.spyOn(transports[0], 'close').mockRejectedValueOnce(new Error('exit not proven'));
+ await expect(host.shutdown('test', { throwOnTransportError: true })).rejects.toThrow('exit not proven');
+ expect(host.writerCandidate).toBe(proof);
+ close.mockRestore();
+ await host.shutdown('confirmed', { throwOnTransportError: true });
+ expect(host.writerCandidate).toBeNull();
+ await host.ensureStarted();
+ expect(host.writerCandidate).toBeNull();
+ // A late old notification cannot turn the replacement into an old writer.
+ transports[0].emit({ method: 'thread/started', params: { thread: { id: 'source' } } });
+ expect(host.writerCandidate).toBeNull();
+ await host.request('thread/start');
+ expect(host.writerCandidate).not.toBe(proof);
+ expect(host.writerCandidate).not.toBeNull();
+ } finally { await host.retire(); }
+ });
+});
+
describe('AppServerHost isolated account lifecycle', () => {
it.each([false, true])('rejects persistent native policy before task dispatch (OAuth: %s)', async oauth => {
const transport = new NotificationTransport(() => ({ config: { cli_auth_credentials_store: 'file' } }));
@@ -489,7 +523,124 @@ const logger: Logger = {
child: () => logger,
};
+describe('native SQLite initialization recovery', () => {
+ class FailedNativeTransport extends NotificationTransport {
+ failed = false;
+ closeGate: Promise<void> = Promise.resolve();
+ override async writeLine(line: string) {
+ this.lines.push(line);
+ this.failed = true;
+ await super.close('native SQLite exited');
+ }
+ nativeSqliteInitializationFailed() { return this.failed; }
+ override async close(reason?: string) { await this.closeGate; await super.close(reason); }
+ }
+
+ it('shares recovery, waits for close, and sends the task only to the replacement', async () => {
+ const failed = new FailedNativeTransport();
+ let release!: () => void;
+ failed.closeGate = new Promise(resolve => { release = resolve; });
+ const healthy = new NotificationTransport();
+ const createTransport = vi.fn().mockReturnValueOnce(failed).mockReturnValue(healthy);
+ const host = new AppServerHost({ createTransport, logger, clientInfo: { name: 'test', version: '0' } });
+ try {
+ const first = host.ensureStarted();
+ expect(host.ensureStarted()).toBe(first);
+ await vi.waitFor(() => expect(failed.failed).toBe(true));
+ expect(createTransport).toHaveBeenCalledTimes(1);
+ release();
+ await first;
+ await host.request('thread/start', {});
+ expect(createTransport).toHaveBeenCalledTimes(2);
+ expect(failed.lines.map(line => JSON.parse(line).method)).toEqual(['initialize']);
+ expect(healthy.lines.map(line => JSON.parse(line).method)).toEqual(['initialize', 'thread/start']);
+ } finally { release(); await host.retire(); }
+ });
+
+ it.each(['exhaust', 'shutdown', 'retire', 'timeout', 'close-failure'] as const)('stops recovery on %s', async mode => {
+ let release!: () => void;
+ const gate = new Promise<void>(resolve => { release = resolve; });
+ const failed = new FailedNativeTransport();
+ if (mode !== 'exhaust') failed.closeGate = gate;
+ if (mode === 'close-failure') failed.close = vi.fn(async () => { await gate; throw new Error('exit unconfirmed'); });
+ const createTransport = vi.fn(() => mode === 'exhaust' ? new FailedNativeTransport() : failed);
+ const host = new AppServerHost({ createTransport, logger, clientInfo: { name: 'test', version: '0' } });
+ const started = mode === 'timeout' ? host.ensureStartedWithTimeout(10, 'fixture') : host.ensureStarted();
+ const rejection = expect(started).rejects.toThrow(mode === 'timeout' ? /timed out/ : mode === 'close-failure' ? /exit unconfirmed/ : /initialization stopped/);
+ if (mode === 'exhaust') {
+ await rejection;
+ expect(createTransport).toHaveBeenCalledTimes(3);
+ } else {
+ await vi.waitFor(() => expect(failed.failed).toBe(true));
+ const stopped = mode === 'shutdown' ? host.shutdown() : mode === 'retire' ? host.retire() : undefined;
+ if (mode === 'timeout') await rejection;
+ release();
+ await rejection;
+ await stopped;
+ await new Promise(resolve => setTimeout(resolve, 0));
+ expect(createTransport).toHaveBeenCalledTimes(1);
+ }
+ await host.retire();
+ });
+
+ it('does not retry an initialize RPC rejection', async () => {
+ const createTransport = vi.fn(() => new RejectedInitializeTransport());
+ const host = new AppServerHost({ createTransport, logger, clientInfo: { name: 'test', version: '0' } });
+ await expect(host.ensureStarted()).rejects.not.toBeInstanceOf(CodexNativeInitializationStoppedError);
+ expect(createTransport).toHaveBeenCalledTimes(1);
+ await host.retire();
+ });
+
+ it('does not retry credential installation after native initialization', async () => {
+ const transport = new NotificationTransport(() => ({ config: { cli_auth_credentials_store: 'ephemeral' } }));
+ const createTransport = vi.fn(() => transport);
+ const host = new AppServerHost({ createTransport, logger, clientInfo: { name: 'test', version: '0' },
+ externalAuth: { readTokens: async () => { throw new Error('synthetic official account rejected'); } },
+ });
+ await expect(host.request('thread/start', {})).rejects.toThrow('Codex account authentication is unavailable or has changed');
+ expect(createTransport).toHaveBeenCalledTimes(1);
+ expect(transport.lines.map(line => JSON.parse(line).method)).not.toContain('thread/start');
+ await host.retire();
+ });
+
+ it('never replays a task RPC failure after initialize', async () => {
+ const transport = new NotificationTransport(method => {
+ if (method === 'thread/start') throw new Error('synthetic task write failed');
+ return {};
+ });
+ const createTransport = vi.fn(() => transport);
+ const host = new AppServerHost({ createTransport, logger, clientInfo: { name: 'test', version: '0' } });
+ await expect(host.request('thread/start', {})).rejects.toThrow();
+ expect(createTransport).toHaveBeenCalledTimes(1);
+ expect(transport.lines.filter(line => JSON.parse(line).method === 'thread/start')).toHaveLength(1);
+ await host.retire();
+ });
+});
+
describe('AppServerHost.request startup timeout', () => {
+ it.each([undefined, 1000])('checks dispatch after the final startup await (timeout=%s)', async (timeoutMs) => {
+ const transport = new NotificationTransport();
+ const host = new AppServerHost({ createTransport: () => transport, logger, clientInfo: { name: 'test', version: '0' } });
+ try {
+ await host.ensureStarted();
+ let release!: () => void;
+ const gate = new Promise<void>((resolve) => { release = resolve; });
+ const ensure = host.ensureStarted.bind(host);
+ vi.spyOn(host, 'ensureStarted').mockImplementationOnce(async () => { await gate; return ensure(); });
+ let valid = true;
+ const beforeDispatch = vi.fn(() => { if (!valid) throw new Error('route expired'); });
+ const pending = host.request('thread/start', {}, { timeoutMs, beforeDispatch });
+ expect(beforeDispatch).not.toHaveBeenCalled();
+ valid = false;
+ release();
+ await expect(pending).rejects.toThrow('route expired');
+ expect(transport.lines.some((line) => JSON.parse(line).method === 'thread/start')).toBe(false);
+ valid = true;
+ await host.request('thread/start', {}, { timeoutMs, beforeDispatch });
+ expect(transport.lines.filter((line) => JSON.parse(line).method === 'thread/start')).toHaveLength(1);
+ } finally { await host.shutdown(); }
+ });
+
it('bounds a hung ensureStarted by the caller-provided timeoutMs (greptile R6 P1)', async () => {
// 冷启动 / transport 重建时 ensureStarted 本身也可能永不返回 — 调用方显式
// 给的 timeoutMs 必须同样覆盖启动路径, 否则「关键 RPC 加超时」形同虚设。
diff --git a/packages/maker-core/src/agents/codex/app-server/host.ts b/packages/maker-core/src/agents/codex/app-server/host.ts
index 19c788b9f9..d4ee0e19fe 100644
--- a/packages/maker-core/src/agents/codex/app-server/host.ts
+++ b/packages/maker-core/src/agents/codex/app-server/host.ts
@@ -329,6 +329,9 @@ interface BufferedNotification {
ts: number;
}
+/** All native attempts have exited before this error is exposed to a task startup. */
+export class CodexNativeInitializationStoppedError extends Error {}
+
export class AppServerHost {
private readonly externalAuth: CodexExternalAuthSession | undefined;
private readonly connectionId = randomUUID();
@@ -337,8 +340,13 @@ export class AppServerHost {
private readonly threadUnsubscribeTimeoutMs: number;
private client: AppServerClient | null = null;
+ // Negative proof belongs to the exact transport, not readiness or provider.
+ // Any application RPC may load a thread (including future protocol methods).
+ // Bootstrap initialize/config/auth and the read-only writer probe do not.
+ private readonly writerCandidates = new WeakSet<AppServerClient>();
/** 同次 ensureStarted 并发调用共享一个 init Promise (避免重复 spawn)。 */
private startPromise: Promise<InitializeResponse> | null = null;
+ private nativeInitializationEpoch = 0;
private readonly subscribers = new Map<string, ThreadEventHandlers>();
/** root / descendant threadId → 当前拥有该子树订阅的 root threadId。 */
@@ -624,6 +632,7 @@ export class AppServerHost {
started,
new Promise<never>((_, reject) => {
timer = setTimeout(() => {
+ this.nativeInitializationEpoch++;
reject(new Error(`app-server startup (for ${label}) timed out after ${timeoutMs}ms`));
}, timeoutMs);
timer.unref?.();
@@ -637,11 +646,19 @@ export class AppServerHost {
}
}
- private async bootstrap(capabilities?: InitializeCapabilities): Promise<InitializeResponse> {
+ private async bootstrap(
+ capabilities?: InitializeCapabilities,
+ nativeAttempt = 0,
+ nativeEpoch = this.nativeInitializationEpoch,
+ ): Promise<InitializeResponse> {
const client = new AppServerClient({
createTransport: this.opts.createTransport,
logger: this.opts.logger,
- onTransportError: (err) => this.handleTransportError(err),
+ onTransportError: (err) => {
+ // Keep the shared startPromise while recovering this one pre-protocol
+ // failure. Every other transport error retains the normal host lifecycle.
+ if (!client.nativeSqliteInitializationFailed()) this.handleTransportError(err);
+ },
onAuthInvalidated: this.opts.onAuthInvalidated,
captureCredentialGeneration: this.opts.captureCredentialGeneration,
});
@@ -665,7 +682,10 @@ export class AppServerHost {
// 注册 notification handlers BEFORE initialize: server 在握手响应前可能就推了
// banner / 启动 notification, 漏接就丢。
for (const method of SUBSCRIBED_METHODS) {
- client.onNotification(method, (params) => this.routeNotification(method, params));
+ client.onNotification(method, (params) => {
+ if (extractThreadId(method, params)) this.writerCandidates.add(client);
+ this.routeNotification(method, params);
+ });
}
// ServerRequest handlers (Phase 2 approval) — 同样在 initialize 前注册,
@@ -834,7 +854,21 @@ export class AppServerHost {
optOutNotificationMethods: NOTIFICATIONS_TO_OPT_OUT,
...capabilities,
};
- const resp = await client.initialize(this.opts.clientInfo, mergedCapabilities);
+ let resp: InitializeResponse;
+ try {
+ resp = await client.initialize(this.opts.clientInfo, mergedCapabilities);
+ } catch (error) {
+ if (!client.nativeSqliteInitializationFailed()) throw error;
+ // No task/config/authentication RPC has been submitted. The transport
+ // proves natural exit; still use the existing strict close barrier.
+ await client.close({ reason: 'native SQLite initialization failed', throwOnTransportError: true });
+ if (nativeAttempt >= 2 || nativeEpoch !== this.nativeInitializationEpoch
+ || this.retired || this.shuttingDown || this.client !== client) {
+ throw new CodexNativeInitializationStoppedError('Codex native SQLite initialization stopped', { cause: error });
+ }
+ this.logger.warn('retrying exited native SQLite initialization', { attempt: nativeAttempt + 2, maxAttempts: 3 });
+ return this.bootstrap(capabilities, nativeAttempt + 1, nativeEpoch);
+ }
if (this.opts.requireEphemeralAuth || this.externalAuth) {
// Requirements can override CLI configuration. Reject before any task RPC
// or token installation; initialization has already loaded native config.
@@ -865,7 +899,7 @@ export class AppServerHost {
async request<R = unknown>(
method: string,
params?: unknown,
- opts?: { timeoutMs?: number },
+ opts?: { timeoutMs?: number; beforeDispatch?: () => void },
): Promise<R> {
// 冷启动 / transport 重建时 ensureStarted 本身也可能永不返回 (远端 daemon
// bootstrap 挂死 / SSH 通道无响应) — 调用方显式给 timeoutMs 时同样给它
@@ -882,6 +916,7 @@ export class AppServerHost {
started,
new Promise<never>((_, reject) => {
timer = setTimeout(() => {
+ this.nativeInitializationEpoch++;
reject(new Error(`app-server startup (for ${method}) timed out after ${opts.timeoutMs}ms`));
}, opts.timeoutMs);
timer.unref?.();
@@ -900,10 +935,14 @@ export class AppServerHost {
throw new Error(`app-server startup (for ${method}) consumed the entire ${opts.timeoutMs}ms timeout budget`);
}
if (!this.client) throw new Error('AppServerHost: client missing after ensureStarted (unreachable)');
+ opts?.beforeDispatch?.();
+ if (method !== 'thread/loaded/list') this.writerCandidates.add(this.client);
return this.client.request<R>(method, params, { ...opts, timeoutMs: remaining });
}
await started;
if (!this.client) throw new Error('AppServerHost: client missing after ensureStarted (unreachable)');
+ opts?.beforeDispatch?.();
+ if (method !== 'thread/loaded/list') this.writerCandidates.add(this.client);
return this.client.request<R>(method, params, opts);
}
@@ -930,6 +969,7 @@ export class AppServerHost {
reason = 'AppServerHost.shutdown()',
opts?: { throwOnTransportError?: boolean },
): Promise<void> {
+ this.nativeInitializationEpoch++;
if (!this.shutdownPromise) {
this.shuttingDown = true;
const client = this.client;
@@ -1084,6 +1124,7 @@ export class AppServerHost {
if (this.subscribers.has(threadId)) {
this.logger.warn('overwriting thread subscription', { threadId });
}
+ if (this.client) this.writerCandidates.add(this.client);
this.subscribers.set(threadId, handlers);
this.lineageRoots.set(threadId, threadId);
this.notifyThreadHandlerWaiters(threadId);
@@ -1660,6 +1701,15 @@ export class AppServerHost {
return this.subscribers.has(threadId);
}
+ /**
+ * Opaque concrete process identity which may own a writer. Null proves no
+ * application request/thread evidence in this process. A failed shutdown keeps
+ * the client (and evidence); a confirmed exit/restart gets a fresh identity.
+ */
+ get writerCandidate(): object | null {
+ return this.client && this.writerCandidates.has(this.client) ? this.client : null;
+ }
+
/** 是否已经 spawn 过子进程 (但可能已 close)。 */
get hasStarted(): boolean {
return this.client !== null;
diff --git a/packages/maker-core/src/agents/codex/app-server/stdioTransport.test.ts b/packages/maker-core/src/agents/codex/app-server/stdioTransport.test.ts
index b62084286b..df57d72c55 100644
--- a/packages/maker-core/src/agents/codex/app-server/stdioTransport.test.ts
+++ b/packages/maker-core/src/agents/codex/app-server/stdioTransport.test.ts
@@ -10,6 +10,8 @@ vi.mock('node:child_process', () => ({ spawn: mocks.spawn }));
vi.mock('node:readline', () => ({ createInterface: mocks.createInterface }));
import { createStdioTransport } from './stdioTransport.js';
+import { AppServerHost, CodexNativeInitializationStoppedError } from './host.js';
+import type { Logger } from '../../../interfaces/logger.js';
function makeEmitterStream() {
const stream = new EventEmitter() as EventEmitter & { setEncoding: ReturnType<typeof vi.fn> };
@@ -62,6 +64,82 @@ afterEach(() => {
});
describe('createStdioTransport process observer', () => {
+ it.each(['exit', 'pending', 'stdout', 'signal', 'other-error', 'different-path'])('classifies only a confirmed pre-protocol SQLite exit (%s)', (scenario) => {
+ const child = makeChild();
+ mocks.spawn.mockReturnValue(child);
+ const transport = createStdioTransport({ binaryPath: 'codex' });
+ const error = scenario === 'other-error' ? 'Error: failed to load configuration: revoked'
+ : `Error: failed to initialize sqlite state runtime under /synthetic: failed to initialize state runtime at ${scenario === 'different-path' ? '/other' : '/synthetic'}`;
+ child.stderr.emit('data', `${error}\n`);
+ if (scenario === 'stdout') child.stdout.emit('data', '{}');
+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(false);
+ if (scenario !== 'pending') {
+ child.emit('exit', 1, scenario === 'signal' ? 'SIGTERM' : null);
+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(false);
+ child.emit('close', 1, scenario === 'signal' ? 'SIGTERM' : null);
+ }
+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(scenario === 'exit');
+ });
+ it.each(['/synthetic/db', String.raw`C:\synthetic\db`])('drains split fatal output after physical exit (%s)', async (home) => {
+ const child = makeChild();
+ mocks.spawn.mockReturnValue(child);
+ const disposed = vi.fn();
+ const transport = createStdioTransport({ binaryPath: 'codex', onProcessSpawned: () => disposed });
+ const closed = vi.fn();
+ const stderr = vi.fn();
+ transport.onClose(closed);
+ transport.onStderr?.(stderr);
+ child.stderr.emit('data', `diagnostic\r\nError: failed to initialize sqlite state runtime under ${home}: failed to initialize state runtime at `);
+ child.emit('exit', 1, null);
+ expect(disposed).toHaveBeenCalledOnce();
+ expect(closed).not.toHaveBeenCalled();
+ expect(mocks.createInterface.mock.results[0]!.value.close).not.toHaveBeenCalled();
+ child.stderr.emit('data', home + '\r'); // No final newline.
+ child.emit('close', 1, null);
+ expect(stderr).toHaveBeenLastCalledWith(`Error: failed to initialize sqlite state runtime under ${home}: failed to initialize state runtime at ${home}`);
+ expect(closed).toHaveBeenCalledOnce();
+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(true);
+ await transport.close('strict cleanup');
+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(true);
+ expect(child.kill).not.toHaveBeenCalled();
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it.each(['stdout', 'cancel', 'drain-timeout'])('refuses recovery when %s arrives between exit and drain', async (scenario) => {
+ const child = makeChild();
+ mocks.spawn.mockReturnValue(child);
+ const transport = createStdioTransport({ binaryPath: 'codex', outputDrainMs: 25 });
+ const closed = vi.fn();
+ transport.onClose(closed);
+ child.stderr.emit('data', 'Error: failed to initialize sqlite state runtime under /x: failed to initialize state runtime at /x');
+ child.emit('exit', 1, null);
+ expect(closed).not.toHaveBeenCalled();
+ if (scenario === 'stdout') child.stdout.emit('data', '{}');
+ if (scenario === 'cancel') await transport.close('initialize timeout / cancellation');
+ if (scenario === 'drain-timeout') await vi.advanceTimersByTimeAsync(25);
+ child.emit('close', 1, null);
+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(false);
+ expect(closed).toHaveBeenCalledOnce();
+ await transport.close();
+ expect(child.kill).not.toHaveBeenCalled();
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it('cancels recovery when the drained stderr callback closes synchronously', async () => {
+ const child = makeChild();
+ mocks.spawn.mockReturnValue(child);
+ const transport = createStdioTransport({ binaryPath: 'codex' });
+ transport.onStderr?.(() => { void transport.close('callback cancelled startup'); });
+ const closed = vi.fn();
+ transport.onClose(closed);
+ child.stderr.emit('data', 'Error: failed to initialize sqlite state runtime under /x: failed to initialize state runtime at /x');
+ child.emit('exit', 1, null);
+ child.emit('close', 1, null);
+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(false);
+ expect(closed).toHaveBeenCalledExactlyOnceWith({ reason: 'callback cancelled startup' });
+ await transport.close();
+ });
+
it('starts the app-server without a visible Windows console', () => {
mocks.spawn.mockReturnValue(makeChild());
@@ -137,6 +215,58 @@ describe('createStdioTransport process observer', () => {
});
});
+describe('production stdio initialization recovery', () => {
+ it.each(['recover', 'exhaust', 'timeout'])('keeps drain classification and the three-process budget on %s', async (scenario) => {
+ const logger: Logger = { trace() {}, debug() {}, info() {}, warn() {}, error() {}, fatal() {}, child: () => logger };
+ const children: ReturnType<typeof makeChild>[] = [];
+ const readers: EventEmitter[] = [];
+ const requests: string[][] = [];
+ mocks.createInterface.mockImplementation(() => {
+ const reader = Object.assign(new EventEmitter(), { close: vi.fn() });
+ readers.push(reader); return reader;
+ });
+ mocks.spawn.mockImplementation(() => {
+ const child = makeChild(4321 + children.length);
+ const index = children.length;
+ children.push(child); requests.push([]);
+ child.stdin.end.mockImplementation(() => { child.emit('exit', 0, null); child.emit('close', 0, null); });
+ child.stdin.write.mockImplementation((line: string, _encoding: string, done: () => void) => {
+ const rpc = JSON.parse(line);
+ if (rpc.method) requests[index].push(rpc.method);
+ queueMicrotask(() => {
+ if (index === 2 && scenario === 'recover') {
+ if (rpc.id != null) readers[index].emit('line', JSON.stringify({ id: rpc.id, result: {} }));
+ } else if (rpc.method === 'initialize') {
+ child.stderr.emit('data', 'Error: failed to initialize sqlite state runtime under /x: failed to initialize state runtime at ');
+ child.emit('exit', 1, null);
+ // Late pipes: timeout must revoke retry eligibility before close.
+ setTimeout(() => { child.stderr.emit('data', '/x'); child.emit('close', 1, null); }, 20);
+ }
+ });
+ done(); return true;
+ });
+ return child;
+ });
+ const host = new AppServerHost({ logger, clientInfo: { name: 'test', version: '0' },
+ createTransport: () => createStdioTransport({ binaryPath: 'codex' }),
+ });
+ const started = scenario === 'timeout' ? host.ensureStartedWithTimeout(10, 'test') : host.ensureStarted();
+ const result = scenario === 'recover' ? expect(started).resolves.toBeDefined()
+ : scenario === 'exhaust' ? expect(started).rejects.toBeInstanceOf(CodexNativeInitializationStoppedError)
+ : expect(started).rejects.toThrow('timed out');
+ await vi.advanceTimersByTimeAsync(100);
+ await result;
+ expect(children).toHaveLength(scenario === 'timeout' ? 1 : 3);
+ if (scenario === 'recover') {
+ await host.request('thread/start');
+ children[0].emit('exit', 1, null); children[0].emit('close', 1, null);
+ expect(host.hasStarted).toBe(true);
+ expect(requests).toEqual([['initialize'], ['initialize'], ['initialize', 'thread/start']]);
+ } else expect(requests.every(methods => methods.every(method => method === 'initialize'))).toBe(true);
+ await host.retire();
+ });
+});
+
describe('close() 强杀兜底 (#3699)', () => {
it('SIGTERM 后进程未退出 → 宽限期到点补 SIGKILL(卡死 app-server 不再活体泄漏)', async () => {
vi.useFakeTimers();
diff --git a/packages/maker-core/src/agents/codex/app-server/stdioTransport.ts b/packages/maker-core/src/agents/codex/app-server/stdioTransport.ts
index 7d967a1871..9f714a77b8 100644
--- a/packages/maker-core/src/agents/codex/app-server/stdioTransport.ts
+++ b/packages/maker-core/src/agents/codex/app-server/stdioTransport.ts
@@ -5,7 +5,7 @@
* - 构造时同步 spawn 子进程 (跟原版 spawnProcess 一致)
* - readline on('line') → fan-out 给 onLine handlers
* - stderr → 整行 normalize 后 fan-out 给 onStderr handlers
- * - child.on('exit') 或我们调 close() → 触发 onClose, 之后 writeLine 都 reject
+ * - child.on('close')(输出已排空)或我们调 close() → 触发 onClose, 之后 writeLine 都 reject
*/
import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
@@ -34,12 +34,15 @@ export interface StdioTransportOptions {
forceKillGraceMs?: number;
/** SIGKILL 后确认退出的时间;仅测试注入。 */
killConfirmationMs?: number;
+ /** 自然退出后等待 stdio 排空的上限;仅测试注入。 */
+ outputDrainMs?: number;
}
// 合计 3s,给 Desktop 6s 退出预算中的其它收尾留出时间。
const GRACEFUL_CLOSE_MS = 1_500;
const FORCE_KILL_GRACE_MS = 1_000;
const KILL_CONFIRMATION_MS = 500;
+const OUTPUT_DRAIN_MS = 1_000;
export function createStdioTransport(opts: StdioTransportOptions): Transport {
if (!opts.binaryPath) {
@@ -60,6 +63,13 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {
let closed = false;
let closePromise: Promise<void> | null = null;
let exited = false;
+ let sawStdout = false;
+ let exitCode: number | null = null;
+ let exitSignal: NodeJS.Signals | null = null;
+ let outputFinalized = false;
+ let drainTimer: ReturnType<typeof setTimeout> | undefined;
+ let sqliteInitializationError = false;
+ let nativeSqliteInitializationFailed = false;
let resolveExit!: () => void;
const exitPromise = new Promise<void>((resolve) => { resolveExit = resolve; });
@@ -89,6 +99,7 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {
// stdout NDJSON 增量解析: readline 处理 \r\n / \n / EOF, 单行触发 callback。
child.stdout.setEncoding('utf8');
+ child.stdout.on('data', () => { sawStdout = true; });
const rl: Interface = createInterface({
input: child.stdout,
crlfDelay: Infinity,
@@ -103,20 +114,26 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {
for (const cb of lineHandlers) cb(line);
});
- // stderr 当诊断信息流, 不参与协议。按行 fan-out, client 层做 ANSI 剥除/分级。
+ // stderr 不参与任务/认证协议;仅识别本机原生启动失败,且必须再有自然退出证据。
+ // 其它内容仍按诊断行 fan-out,client 层做 ANSI 剥除/分级。
child.stderr.setEncoding('utf8');
let stderrBuffer = '';
+ const emitStderrLine = (line: string): void => {
+ const trimmed = line.replace(/\r$/, '');
+ if (!trimmed) return;
+ // Exact pre-protocol fatal in the pinned native runtime, not a generic SQL log.
+ const match = /^Error: failed to initialize sqlite state runtime under (.+): failed to initialize state runtime at (.+)$/.exec(trimmed);
+ if (match && match[1] === match[2]) sqliteInitializationError = true;
+ for (const cb of stderrHandlers) cb(trimmed);
+ };
child.stderr.on('data', (chunk: string) => {
+ if (outputFinalized) return;
stderrBuffer += chunk;
const idx = stderrBuffer.lastIndexOf('\n');
if (idx === -1) return;
const lines = stderrBuffer.slice(0, idx).split('\n');
stderrBuffer = stderrBuffer.slice(idx + 1);
- for (const line of lines) {
- const trimmed = line.replace(/\r$/, '');
- if (!trimmed) continue;
- for (const cb of stderrHandlers) cb(trimmed);
- }
+ for (const line of lines) emitStderrLine(line);
});
const fireClose = (reason: string): void => {
@@ -128,27 +145,54 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {
}
};
- const finishProcess = (reason: string): void => {
+ const finishOutput = (reason: string, drained: boolean): void => {
+ if (outputFinalized) return;
+ outputFinalized = true;
+ if (drainTimer) clearTimeout(drainTimer);
+ if (drained) emitStderrLine(stderrBuffer);
+ stderrBuffer = '';
+ nativeSqliteInitializationFailed = drained && exited && exitCode === 1 && exitSignal === null
+ && !closed && !sawStdout && sqliteInitializationError;
+ try { rl.close(); } catch { /* already closed */ }
+ fireClose(reason);
+ };
+
+ // Physical exit is independent of pipe drainage (including inherited pipes).
+ // Strict close uses only this proof; retry classification needs both proofs.
+ const confirmExit = (): void => {
if (exited) return;
exited = true;
- try { rl.close(); } catch { /* already closed */ }
try { disposeProcessRegistration?.(); } catch { /* best-effort diagnostic cleanup */ }
disposeProcessRegistration = undefined;
resolveExit();
- fireClose(reason);
};
+ const exitReason = () => `child exited (${exitSignal ? `signal=${exitSignal}` : `exit code=${exitCode ?? 'null'}`})`;
child.on('error', (err) => {
const reason = `child error: ${err.message}`;
- // spawn 失败没有进程;运行中的 error(例如 kill 失败)不是退出证据。
- if (child.pid == null) finishProcess(reason);
- else fireClose(reason);
+ // spawn failure has no process; a running process error is not exit proof.
+ if (child.pid == null) {
+ confirmExit();
+ finishOutput(reason, false);
+ } else fireClose(reason);
+ });
+ child.stdin.on('error', (err) => {
+ if (!exited) fireClose(`child stdin error: ${err.message}`);
});
- child.stdin.on('error', (err) => fireClose(`child stdin error: ${err.message}`));
child.on('exit', (code, signal) => {
- const reason = signal ? `signal=${signal}` : `exit code=${code ?? 'null'}`;
- finishProcess(`child exited (${reason})`);
+ if (exited) return;
+ exitCode = code;
+ exitSignal = signal;
+ confirmExit();
+ if (closed) finishOutput(exitReason(), false);
+ else {
+ // An inherited pipe must not leave initialize pending forever. A drain
+ // deadline cannot prove complete output, so it never qualifies for retry.
+ drainTimer = setTimeout(() => finishOutput(`${exitReason()}; output drain timed out`, false), opts.outputDrainMs ?? OUTPUT_DRAIN_MS);
+ drainTimer.unref?.();
+ }
});
+ child.on('close', () => finishOutput(exitReason(), true));
const waitForExit = async (timeoutMs: number): Promise<boolean> => {
if (exited) return true;
@@ -165,8 +209,9 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {
};
return {
+ nativeSqliteInitializationFailed: () => nativeSqliteInitializationFailed,
writeLine(line: string): Promise<void> {
- if (closed || !child.stdin.writable) {
+ if (closed || exited || !child.stdin.writable) {
return Promise.reject(new Error('StdioTransport.writeLine after close'));
}
return new Promise<void>((resolve, reject) => {
@@ -209,7 +254,16 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {
close(reason = 'StdioTransport.close()'): Promise<void> {
// 首次严格关闭可以超时;迟到的真实 exit 使后续幂等检查成功。
- if (exited) return exitPromise;
+ if (exited) {
+ // Cancellation during exit → drain must win over late fatal output.
+ // Already finalized natural failure retains its proof for strict cleanup.
+ if (!closed) {
+ nativeSqliteInitializationFailed = false;
+ if (!outputFinalized) finishOutput(reason, false);
+ else fireClose(reason); // Synchronous cancellation from a final stderr/line callback.
+ }
+ return exitPromise;
+ }
if (!closePromise) {
// 先发布 Promise,再调用可能同步重入 close() 的监听器。
closePromise = Promise.resolve().then(async () => {
diff --git a/packages/maker-core/src/agents/codex/app-server/transport.ts b/packages/maker-core/src/agents/codex/app-server/transport.ts
index 8a3fb96cc0..4c14c581e1 100644
--- a/packages/maker-core/src/agents/codex/app-server/transport.ts
+++ b/packages/maker-core/src/agents/codex/app-server/transport.ts
@@ -43,6 +43,8 @@ export type CloseHandler = (info: TransportCloseInfo) => void;
* 字节流双向 transport。一个 transport 实例只服务一个 client (1:1)。
*/
export interface Transport {
+ /** Local native SQLite bootstrap failed before any stdout, with a confirmed natural exit. */
+ nativeSqliteInitializationFailed?(): boolean;
/**
* 把一行 NDJSON 异步写到对端。promise resolve 仅表示字节进入了
* 操作系统 buffer (或 ws send buffer), 不保证对端收到 / 处理。
diff --git a/packages/maker-core/src/agents/codex/index.test.ts b/packages/maker-core/src/agents/codex/index.test.ts
index e89653c2d6..2ddbd20a29 100644
--- a/packages/maker-core/src/agents/codex/index.test.ts
+++ b/packages/maker-core/src/agents/codex/index.test.ts
@@ -13,7 +13,7 @@ import {
import { CodexForkError } from './fork-error.js';
import { Session } from '../../session.js';
import { Method } from './app-server/protocol.js';
-import type { ThreadEventHandlers } from './app-server/host.js';
+import type { AppServerHost, ThreadEventHandlers } from './app-server/host.js';
import {
AUTO_REVIEW_SOURCE_CONTENT,
INHERITED_CAPABILITY_SELECTION,
@@ -47,6 +47,7 @@ const { MockCodexTransport, createdTransports, createdStdioOptions } = vi.hoiste
class MockCodexTransport {
static threadSeq = 1;
+ static userAgent = 'mock-codex';
static failThreadStart = false;
static dropThreadUnsubscribe = false;
static dropModelList = false;
@@ -69,7 +70,7 @@ const { MockCodexTransport, createdTransports, createdStdioOptions } = vi.hoiste
error?: { code: number; message: string; data?: unknown };
}>();
- constructor() {
+ constructor(private readonly spawnArgs: string[] = []) {
MockCodexTransport.onCreate?.(this);
}
@@ -88,7 +89,7 @@ const { MockCodexTransport, createdTransports, createdStdioOptions } = vi.hoiste
this.emitLine({
id: req.id,
result: {
- userAgent: 'mock-codex',
+ userAgent: MockCodexTransport.userAgent,
codexHome: '/tmp/mock-codex-home',
platformOs: 'macos',
defaultModel: 'gpt-5.4',
@@ -188,7 +189,7 @@ const { MockCodexTransport, createdTransports, createdStdioOptions } = vi.hoiste
if (req.method === 'config/read') {
this.emitLine({
id: req.id,
- result: { config: { features: { memories: this.memoryEnabled } } },
+ result: { config: { cli_auth_credentials_store: this.spawnArgs.includes('cli_auth_credentials_store="ephemeral"') ? "ephemeral" : "file", features: { memories: this.memoryEnabled } } },
});
return;
}
@@ -279,13 +280,14 @@ vi.mock('./app-server/stdioTransport.js', () => ({
}) => {
createdStdioOptions.push(opts);
opts.onProcessSpawned?.(7_000 + createdStdioOptions.length);
- const transport = new MockCodexTransport();
+ const transport = new MockCodexTransport(opts.extraArgs);
createdTransports.push(transport);
return transport;
},
}));
beforeEach(() => {
+ MockCodexTransport.userAgent = 'mock-codex';
createdTransports.length = 0;
createdStdioOptions.length = 0;
MockCodexTransport.threadSeq = 1;
@@ -366,6 +368,532 @@ function createDeps(
};
}
+describe('Codex official OAuth host isolation', () => {
+ function isolatedDeps() {
+ return createDeps({}, {
+ resolveCodexLocalAuthPolicy: (providerId) =>
+ providerId === 'cprov-test' || providerId === 'xd' ? 'isolated' : 'legacy-shared',
+ prepareCodexExtraSpawnConfig: async () => ({
+ extraArgs: [], extraEnv: {}, codexProxyActive: true,
+ }),
+ });
+ }
+
+ it.each([false, true])('keeps gateway authentication independent of an OAuth host (oauthFirst=%s)', async (oauthFirst) => {
+ const deps = isolatedDeps();
+ const authState = vi.fn(async (opts?: { credentialMode?: string }) => ({ authenticated: true, authSource: opts?.credentialMode === 'gateway-key' ? 'api-key' as const : 'oauth' as const }));
+ deps.auth.getState = authState;
+ const agent = new CodexAgent(deps);
+ const start = (providerId: string) => agent.startSession({ sessionId: providerId, providerId, model: 'gpt-5.4', workingDir: '/repo' });
+ try {
+ const first = await start(oauthFirst ? 'openai' : 'xd');
+ const second = await start(oauthFirst ? 'xd' : 'openai');
+ const gatewayIndex = oauthFirst ? 1 : 0;
+ expect(createdTransports).toHaveLength(2);
+ expect(createdTransports.every((transport) => !transport.closed)).toBe(true);
+ expect(createdStdioOptions[gatewayIndex].extraArgs).toContain('cli_auth_credentials_store="ephemeral"');
+ expect(createdStdioOptions[1 - gatewayIndex].extraArgs).not.toContain('cli_auth_credentials_store="ephemeral"');
+ expect(authState.mock.calls.every(([opts]) => opts?.credentialMode !== undefined)).toBe(true);
+ await agent.forceDisposeLocalHostForAuthChange('expired OAuth', { preserveExternalAuth: true });
+ expect(createdTransports[gatewayIndex].closed).toBe(false);
+ expect(createdTransports[1 - gatewayIndex].closed).toBe(true);
+ await first.close(); await second.close();
+ } finally { await agent.dispose(); }
+ });
+
+ it.each(['openai', 'cprov-test'])('detects a retained native writer only across hosts from %s', async (providerId) => {
+ const agent = new CodexAgent(isolatedDeps());
+ try {
+ const source = await agent.startSession({ sessionId: 'source', providerId, model: 'gpt-5.4', workingDir: '/repo' });
+ const sibling = await agent.startSession({ sessionId: 'unrelated', providerId, model: 'gpt-5.4', workingDir: '/repo' });
+ const transport = createdTransports[0];
+ transport.setMockResponse('thread/loaded/list', { result: { data: [source.id, sibling.id], nextCursor: null } });
+ await source.close();
+ const query = { sessionId: 'source', threadId: source.id, model: 'gpt-5.4' };
+ expect(await agent.requiresCodexThreadHostTransfer({ ...query, providerId })).toBe(false);
+ expect(await agent.requiresCodexThreadHostTransfer({ ...query, providerId: providerId === 'openai' ? 'cprov-test' : 'openai' })).toBe(true);
+ expect(await agent.requiresCodexThreadHostTransfer({ ...query, providerId: 'openai', remoteHostId: 'ssh' })).toBe(false);
+ transport.setMockResponse('thread/loaded/list', { result: { data: [sibling.id], nextCursor: null } });
+ expect(await agent.requiresCodexThreadHostTransfer({ ...query, providerId: providerId === 'openai' ? 'cprov-test' : 'openai' })).toBe(false);
+ expect(transport.closed).toBe(false);
+ expect(createdTransports).toHaveLength(1);
+ await sibling.close();
+ } finally { await agent.dispose(); }
+ });
+
+ it.each(['xd', 'cprov-test'])('does not wait for a cold official host while checking %s writers', async (providerId) => {
+ const agent = new CodexAgent(isolatedDeps());
+ let release!: () => void;
+ const gate = new Promise<void>((resolve) => { release = resolve; });
+ let official: Promise<AgentSessionHandle> | undefined;
+ try {
+ const source = await agent.startSession({ sessionId: 'source', providerId, model: 'gpt-5.4', workingDir: '/repo' });
+ createdTransports[0].setMockResponse('thread/loaded/list', { result: { data: [source.id], nextCursor: null } });
+ MockCodexTransport.beforeInitializeResponse = () => gate;
+ official = agent.startSession({ sessionId: 'official', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' });
+ await vi.waitFor(() => expect(createdTransports).toHaveLength(2));
+ const query = { sessionId: 'source', threadId: source.id, model: 'gpt-5.4' };
+ await expect(agent.requiresCodexThreadHostTransfer({ ...query, providerId })).resolves.toBe(false);
+ await source.close();
+ await expect(agent.requiresCodexThreadHostTransfer({ ...query, providerId: 'openai' })).resolves.toBe(true);
+ expect(createdTransports[1].closed).toBe(false);
+ expect(createdTransports[1].lines.map(line => JSON.parse(line).method)).toEqual(['initialize']);
+ } finally {
+ release();
+ await official;
+ await agent.dispose();
+ }
+ });
+
+ it.each(['resolve-success', 'resolve-failure', 'list-success', 'list-failure'])('waits for exact writer retirement during %s', async (window) => {
+ const deps: AgentDeps = isolatedDeps();
+ const agent = new CodexAgent(deps);
+ const internals = agent as unknown as {
+ hosts: Map<string, AppServerHost>;
+ retiringHosts: Map<string, unknown>;
+ retireHostKey(key: string, reason: string, opts: { failIfActive: boolean; logPrefix: string }): Promise<void>;
+ };
+ let releaseQuery = () => {};
+ let releaseExit = () => {};
+ let rejectExit: (error: Error) => void = () => {};
+ const queryGate = new Promise<void>((resolve) => { releaseQuery = resolve; });
+ const exitGate = new Promise<void>((resolve, reject) => { releaseExit = resolve; rejectExit = reject; });
+ try {
+ const source = await agent.startSession({ sessionId: 'source', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' });
+ const sibling = await agent.startSession({ sessionId: 'unrelated', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ await source.close();
+ const host = internals.hosts.get('local')!;
+ const siblingTransport = createdTransports[1];
+ let entered = false;
+ if (window.startsWith('resolve')) {
+ const resolve = deps.resolveCodexLocalAuthPolicy!;
+ deps.resolveCodexLocalAuthPolicy = async (...args) => {
+ entered = true; await queryGate; return resolve(...args);
+ };
+ } else {
+ const request = host.request.bind(host);
+ vi.spyOn(host, 'request').mockImplementation(async (method, params, options) => {
+ if (method === 'thread/loaded/list') { entered = true; await queryGate; return { data: [source.id], nextCursor: null }; }
+ return request(method, params, options);
+ });
+ }
+ const retire = host.retire.bind(host);
+ const retirementSpy = vi.spyOn(host, 'retire').mockImplementation(async (...args) => { await exitGate; return retire(...args); });
+ const decision = agent.requiresCodexThreadHostTransfer({ sessionId: 'source', threadId: source.id, providerId: 'cprov-test', model: 'gpt-5.4' });
+ let settled = false;
+ void decision.then(() => { settled = true; }, () => { settled = true; });
+ await vi.waitFor(() => expect(entered).toBe(true));
+ const retirement = internals.retireHostKey('local', 'test writer race', { failIfActive: false, logPrefix: 'test' });
+ await vi.waitFor(() => expect(retirementSpy).toHaveBeenCalled());
+ expect(internals.hosts.has('local')).toBe(false);
+ if (window.endsWith('failure')) {
+ rejectExit(new Error('writer exit failed'));
+ await retirement;
+ // Even removal of the current registry entry cannot erase the exact host's failure.
+ internals.retiringHosts.delete('local');
+ releaseQuery();
+ await expect(decision).rejects.toThrow('writer exit failed');
+ } else {
+ releaseQuery();
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ expect(settled).toBe(false);
+ releaseExit();
+ await retirement;
+ await expect(decision).resolves.toBe(false);
+ }
+ expect(siblingTransport.closed).toBe(false);
+ retirementSpy.mockRestore();
+ await retire('test cleanup');
+ await sibling.close();
+ } finally { releaseQuery(); releaseExit(); await agent.dispose(); }
+ });
+
+ it('keeps external credentials and subscription hosts alive concurrently', async () => {
+ const agent = new CodexAgent(isolatedDeps());
+ try {
+ const [official, external] = await Promise.all([
+ agent.startSession({ sessionId: 'official', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' }),
+ agent.startSession({ sessionId: 'external', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' }),
+ ]);
+ expect(createdTransports).toHaveLength(2);
+ expect(createdTransports.every((transport) => !transport.closed)).toBe(true);
+ expect(createdStdioOptions.filter((options) =>
+ options.extraArgs?.includes('cli_auth_credentials_store="ephemeral"'),
+ )).toHaveLength(1);
+ await agent.startSession({ sessionId: 'external-again', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ expect(createdTransports).toHaveLength(2);
+ await official.close();
+ expect(createdTransports.every((transport) => !transport.closed)).toBe(true);
+ await external.close();
+ } finally {
+ await agent.dispose();
+ }
+ });
+
+ it.each(['openai', 'cprov-test'])('rebuilds a changed routing signature without retiring the sibling of %s', async (providerId) => {
+ let signature = 'initial';
+ const deps = isolatedDeps();
+ deps.prepareCodexExtraSpawnConfig = async () => ({ extraArgs: [], extraEnv: {}, codexProxyActive: true, codexSubagentRoutingSignature: signature });
+ deps.resolveCodexSubagentRoutingSignature = async () => signature;
+ const coordinate = vi.fn(async () => {});
+ deps.prepareCodexLocalCredentialModeSwitch = coordinate;
+ const agent = new CodexAgent(deps);
+ try {
+ const target = await agent.startSession({ sessionId: 'target-signature', providerId, model: 'gpt-5.4', workingDir: '/repo' });
+ const sibling = await agent.startSession({ sessionId: 'sibling-signature', providerId: providerId === 'openai' ? 'cprov-test' : 'openai', model: 'gpt-5.4', workingDir: '/repo' });
+ const siblingTransport = createdTransports[1];
+ await target.close();
+ signature = 'changed';
+ const replacement = await agent.startSession({ sessionId: 'replacement-signature', providerId, model: 'gpt-5.4', workingDir: '/repo' });
+ expect(createdTransports[0].closed).toBe(true);
+ expect(siblingTransport.closed).toBe(false);
+ expect(createdTransports).toHaveLength(3);
+ if (coordinate.mock.calls.length) expect(coordinate).toHaveBeenCalledWith(expect.objectContaining({ hostKey: target.codexHostKey }));
+ await sibling.close();
+ await replacement.close();
+ } finally { await agent.dispose(); }
+ });
+
+ it('re-evaluates provider switches and resumes on the isolated host', async () => {
+ const agent = new CodexAgent(isolatedDeps());
+ try {
+ const handle = await agent.startSession({ sessionId: 'switch', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ expect(await handle.requiresModelSwitchRebuild?.('gpt-5.4', { providerId: 'openai' })).toBe(true);
+ expect(await handle.requiresModelSwitchRebuild?.('gpt-5.4', { providerId: 'cprov-test' })).toBe(false);
+ const resumed = await agent.startSession({ sessionId: 'resumed', resumeSessionId: '11111111-1111-4111-8111-111111111111', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ expect(createdTransports).toHaveLength(1);
+ await resumed.send({ type: 'user', content: 'resume' });
+ expect(createdTransports[0].lines.some((line) => JSON.parse(line).method === 'thread/resume')).toBe(true);
+ await resumed.close();
+ await handle.close();
+ await agent.forceDisposeLocalHostForAuthChange();
+ expect(createdTransports[0].closed).toBe(true);
+ } finally {
+ await agent.dispose();
+ }
+ });
+
+ it.each(['isolated', 'legacy-shared'] as const)('rebuilds when the actual route policy changes from %s without changing model identity', async (initialPolicy) => {
+ const deps = isolatedDeps();
+ let policy: 'isolated' | 'legacy-shared' = initialPolicy;
+ deps.resolveCodexLocalAuthPolicy = () => policy;
+ const agent = new CodexAgent(deps);
+ try {
+ const handle = await agent.startSession({ sessionId: 'policy-switch', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ expect(await handle.requiresModelSwitchRebuild?.('gpt-5.4', { providerId: 'cprov-test' })).toBe(false);
+ policy = initialPolicy === 'isolated' ? 'legacy-shared' : 'isolated';
+ expect(await handle.requiresModelSwitchRebuild?.('gpt-5.4', { providerId: 'cprov-test' })).toBe(true);
+ await handle.close();
+ } finally {
+ await agent.dispose();
+ }
+ });
+
+ it('normalizes an absent policy callback to legacy compatibility without a false rebuild', async () => {
+ const deps = isolatedDeps();
+ delete deps.resolveCodexLocalAuthPolicy;
+ const agent = new CodexAgent(deps);
+ try {
+ const handle = await agent.startSession({ sessionId: 'legacy-policy', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' });
+ deps.resolveCodexLocalAuthPolicy = () => 'legacy-shared';
+ expect(await handle.requiresModelSwitchRebuild?.('gpt-5.4', { providerId: 'openai' })).toBe(false);
+ await handle.close();
+ } finally {
+ await agent.dispose();
+ }
+ });
+
+ it('retires only the failing external host without invalidating shared OAuth', async () => {
+ const deps = isolatedDeps();
+ const invalidate = vi.fn(async () => undefined);
+ deps.auth.invalidate = invalidate;
+ const agent = new CodexAgent(deps);
+ try {
+ const official = await agent.startSession({ sessionId: 'official-survivor', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' });
+ const external = await agent.startSession({ sessionId: 'external-failure', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ createdTransports[1].setMockResponse(Method.TurnStart, { error: {
+ code: -32000, message: 'OAuth refresh token was already used',
+ data: { reason: 'cloudRequirements', errorCode: 'Auth' },
+ } });
+ await expect(external.send({ type: 'user', content: 'fail' }, { throwOnStartFailure: true })).rejects.toThrow(/refresh token/);
+ await waitForExpectation(() => expect(createdTransports[1].closed).toBe(true));
+ expect(invalidate).not.toHaveBeenCalled();
+ expect(createdTransports[0].closed).toBe(false);
+ await official.send({ type: 'user', content: 'still available' });
+ await external.close();
+ await official.close();
+ } finally {
+ await agent.dispose();
+ }
+ });
+
+ it('uses host-injected credentials for an inferred custom route without gateway or OAuth login', async () => {
+ const deps = isolatedDeps();
+ deps.resolveCodexLocalAuthPolicy = () => 'isolated';
+ const getState = vi.fn<AuthAdapter['getState']>(async (options) => ({ authenticated: options?.credentialMode === 'provider-oauth' }));
+ deps.auth.getState = getState;
+ const agent = new CodexAgent(deps);
+ try {
+ const handle = await agent.startSession({ sessionId: 'inferred', model: 'custom-model', workingDir: '/repo' });
+ expect(getState.mock.calls.every(([options]) => options?.credentialMode === 'provider-oauth')).toBe(true);
+ expect(createdStdioOptions[0].extraArgs).toContain('cli_auth_credentials_store="ephemeral"');
+ await handle.close();
+ } finally {
+ await agent.dispose();
+ }
+ });
+
+ it('preserves external hosts on OAuth invalidation and retires both under an explicit credential change', async () => {
+ const agent = new CodexAgent(isolatedDeps());
+ try {
+ await agent.startSession({ sessionId: 'official-boundary', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' });
+ await agent.startSession({ sessionId: 'external-boundary', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ await agent.forceDisposeLocalHostForAuthChange('revoked OAuth', { preserveExternalAuth: true });
+ expect(createdTransports[0].closed).toBe(true);
+ expect(createdTransports[1].closed).toBe(false);
+ const guard = await agent.beginLocalHostCredentialChange('provider snapshot changed', { allLocalHosts: true, forceRetire: true });
+ try {
+ await guard.retireActiveHost();
+ expect(createdTransports[1].closed).toBe(true);
+ await guard.finalize();
+ } finally {
+ guard.release();
+ }
+ await agent.startSession({ sessionId: 'external-new-generation', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ expect(createdTransports).toHaveLength(3);
+ expect(createdStdioOptions[2].extraArgs).toContain('cli_auth_credentials_store="ephemeral"');
+ } finally {
+ await agent.dispose();
+ }
+ });
+
+ it('preserves custom-context ownership and cleanup on external hosts', async () => {
+ const deps = isolatedDeps();
+ deps.resolveCodexThreadContextWindow = () => 700_000;
+ const onHostRetired = vi.fn(async () => undefined);
+ const prepare = vi.fn<NonNullable<typeof deps.prepareCodexExtraSpawnConfig>>(async () => ({
+ extraArgs: [], extraEnv: {}, codexProxyActive: true, onHostRetired,
+ }));
+ deps.prepareCodexExtraSpawnConfig = prepare;
+ const agent = new CodexAgent(deps);
+ try {
+ const handle = await agent.startSession({ sessionId: 'external-context', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ expect(prepare).toHaveBeenCalledWith([], expect.objectContaining({
+ hostPurpose: 'custom-context', localAuthPolicy: 'isolated',
+ hostScopeKey: 'local-custom-context:external-context:external-auth:1',
+ }));
+ expect(createdStdioOptions[0].extraArgs).toContain('cli_auth_credentials_store="ephemeral"');
+ await handle.close();
+ expect(createdTransports[0].closed).toBe(true);
+ expect(onHostRetired).toHaveBeenCalledOnce();
+ } finally {
+ await agent.dispose();
+ }
+ });
+
+ it.each([false, true])('retires scoped snapshots and blocks new hosts during configuration persistence (review=%s)', async (reviewMode) => {
+ if (reviewMode) MockCodexTransport.userAgent = 'mock-codex/0.145.0';
+ if (reviewMode) MockCodexTransport.onCreate = (transport) => transport.setMockResponse('config/read', { result: { config: { cli_auth_credentials_store: 'ephemeral', mcp_servers: { node_repl: { command: 'synthetic-node-repl' } } } } });
+ const workingDir = await fs.mkdtemp(path.join(os.tmpdir(), 'cindy-scope-change-'));
+ const deps = isolatedDeps();
+ deps.resolveCodexThreadContextWindow = () => 700_000;
+ const agent = new CodexAgent(deps);
+ try {
+ await agent.startSession({ sessionId: 'old-config', ...(reviewMode ? { reviewMode: true as const } : {}), providerId: 'cprov-test', model: 'gpt-5.4', workingDir });
+ const guard = await agent.beginLocalHostCredentialChange('provider snapshot changed', { allLocalHosts: true, forceRetire: true });
+ try {
+ await guard.retireActiveHost();
+ expect(createdTransports[0].closed).toBe(true);
+ const pending = agent.startSession({ sessionId: 'new-config', ...(reviewMode ? { reviewMode: true as const } : {}), providerId: 'cprov-test', model: 'gpt-5.4', workingDir });
+ let completed = false;
+ void pending.then(() => { completed = true; });
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ expect(completed).toBe(false);
+ expect(createdTransports).toHaveLength(1);
+ await guard.finalize();
+ const handle = await pending;
+ expect(createdTransports).toHaveLength(2);
+ expect(handle.codexHostKey).toBe(reviewMode ? 'local-review:new-config:external-auth' : 'local-custom-context:new-config:external-auth');
+ await handle.close();
+ } finally {
+ guard.release();
+ }
+ } finally {
+ await agent.dispose();
+ await fs.rm(workingDir, { recursive: true, force: true });
+ }
+ });
+
+ it.each([false, true])('supersedes an in-flight scoped creation at the configuration boundary (review=%s)', async (reviewMode) => {
+ MockCodexTransport.userAgent = 'mock-codex/0.145.0';
+ if (reviewMode) MockCodexTransport.onCreate = (transport) => transport.setMockResponse('config/read', { result: { config: { cli_auth_credentials_store: 'ephemeral', mcp_servers: { node_repl: { command: 'synthetic-node-repl' } } } } });
+ const workingDir = await fs.mkdtemp(path.join(os.tmpdir(), 'cindy-scope-inflight-'));
+ const deps = isolatedDeps();
+ deps.resolveCodexThreadContextWindow = () => 700_000;
+ const agent = new CodexAgent(deps);
+ let entered!: () => void;
+ let resume!: () => void;
+ const started = new Promise<void>((resolve) => { entered = resolve; });
+ const paused = new Promise<void>((resolve) => { resume = resolve; });
+ MockCodexTransport.beforeInitializeResponse = async () => { entered(); await paused; };
+ try {
+ const pending = agent.startSession({ sessionId: 'creating-scope', ...(reviewMode ? { reviewMode: true as const } : {}), providerId: 'cprov-test', model: 'gpt-5.4', workingDir });
+ await started;
+ const guard = await agent.beginLocalHostCredentialChange('provider snapshot changed', { allLocalHosts: true, forceRetire: true });
+ try {
+ const retired = guard.retireActiveHost();
+ resume();
+ await retired;
+ await guard.finalize();
+ } finally { guard.release(); }
+ MockCodexTransport.beforeInitializeResponse = null;
+ const replacement = await pending;
+ expect(createdTransports[0].lines.some((line) => JSON.parse(line).method === Method.ThreadStart)).toBe(false);
+ expect(createdTransports[0].closed).toBe(true);
+ expect(createdTransports.at(-1)?.closed).toBe(false);
+ await replacement.close();
+ } finally {
+ resume();
+ await agent.dispose();
+ await fs.rm(workingDir, { recursive: true, force: true });
+ }
+ });
+
+ it('does not replay an accepted thread start when the route changes before its response', async () => {
+ const deps = isolatedDeps();
+ let revision = 0;
+ deps.resolveCodexLocalAuthPolicy = () => { const captured = revision; return { policy: 'isolated', isCurrent: () => captured === revision }; };
+ MockCodexTransport.beforeThreadStartResponse = () => { revision++; };
+ const agent = new CodexAgent(deps);
+ try {
+ const handle = await agent.startSession({ sessionId: 'accepted-once', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ expect(createdTransports).toHaveLength(1);
+ expect(createdTransports[0].lines.filter((line) => JSON.parse(line).method === Method.ThreadStart)).toHaveLength(1);
+ await handle.close();
+ } finally { await agent.dispose(); }
+ });
+
+ it('reselects after a route mutation during spawn preparation without allocating a stale transport', async () => {
+ const deps = isolatedDeps();
+ let revision = 0;
+ deps.resolveCodexLocalAuthPolicy = () => {
+ const captured = revision;
+ return { policy: revision === 0 ? 'legacy-shared' : 'isolated', isCurrent: () => captured === revision };
+ };
+ const retired = vi.fn();
+ const prepare = vi.fn(async () => {
+ revision = 1;
+ return { extraArgs: [], extraEnv: {}, codexProxyActive: true, onHostRetired: retired };
+ });
+ deps.prepareCodexExtraSpawnConfig = prepare;
+ const agent = new CodexAgent(deps);
+ try {
+ const handle = await agent.startSession({ sessionId: 'reselect', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ expect(handle.codexHostKey).toBe('local:external-auth');
+ expect(prepare).toHaveBeenCalledTimes(2);
+ expect(retired).toHaveBeenCalledOnce();
+ expect(createdTransports).toHaveLength(1);
+ expect(createdStdioOptions[0].extraArgs).toContain('cli_auth_credentials_store="ephemeral"');
+ expect(createdTransports[0].lines.filter((line) => JSON.parse(line).method === 'thread/start')).toHaveLength(1);
+ await handle.close();
+ } finally { await agent.dispose(); }
+ });
+
+ it('waits for a stable route before comparing temporary context catalog omissions', async () => {
+ const deps = isolatedDeps();
+ let pending = false;
+ let release!: () => void;
+ const barrier = new Promise<void>((resolve) => { release = resolve; });
+ deps.resolveCodexLocalAuthPolicy = async () => { if (pending) await barrier; return 'isolated' as const; };
+ const resolveWindow = vi.fn(() => pending ? null : 700_000);
+ deps.resolveCodexThreadContextWindow = resolveWindow;
+ const agent = new CodexAgent(deps);
+ try {
+ const handle = await agent.startSession({ sessionId: 'context-switch', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ pending = true;
+ resolveWindow.mockClear();
+ const switching = handle.requiresModelSwitchRebuild!('gpt-5.4', { providerId: 'cprov-test' });
+ await new Promise((resolve) => setTimeout(resolve, 10));
+ expect(resolveWindow).not.toHaveBeenCalled();
+ pending = false;
+ release();
+ expect(await switching).toBe(false);
+ expect(createdTransports).toHaveLength(1);
+ expect(createdTransports[0].closed).toBe(false);
+ await handle.close();
+ } finally { release(); await agent.dispose(); }
+ });
+
+ it('cancels a startup waiting for the configuration barrier without reserving a host', async () => {
+ const agent = new CodexAgent(isolatedDeps());
+ const guard = await agent.beginLocalHostCredentialChange('provider snapshot changed', { allLocalHosts: true, forceRetire: true });
+ try {
+ const pending = agent.startSession({ sessionId: 'cancelled-barrier', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ const rejection = expect(pending).rejects.toThrow(/cancelled/);
+ await new Promise((resolve) => setTimeout(resolve, 10));
+ await agent.dispose();
+ await rejection;
+ expect(createdTransports).toHaveLength(0);
+ } finally { guard.release(); await agent.dispose(); }
+ });
+
+ it('reselects a route after a configuration change before sending a thread RPC', async () => {
+ const deps = isolatedDeps();
+ let releaseResolution!: () => void;
+ const resolving = new Promise<void>((resolve) => { releaseResolution = resolve; });
+ const resolveDependency = vi.fn(async () => { await resolving; return 'isolated' as const; });
+ deps.resolveCodexLocalAuthPolicy = resolveDependency;
+ const agent = new CodexAgent(deps);
+ try {
+ const pending = agent.startSession({ sessionId: 'stale-policy', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });
+ await waitForExpectation(() => expect(resolveDependency).toHaveBeenCalledOnce());
+ const guard = await agent.beginLocalHostCredentialChange('provider snapshot changed', { allLocalHosts: true, forceRetire: true });
+ await guard.finalize();
+ releaseResolution();
+ const handle = await pending;
+ expect(resolveDependency).toHaveBeenCalledTimes(2);
+ expect(createdTransports).toHaveLength(1);
+ await handle.close();
+ } finally {
+ releaseResolution();
+ await agent.dispose();
+ }
+ });
+
+ it('does not let spawn preparation upgrade an external route back to disk OAuth', async () => {
+ const deps = isolatedDeps();
+ const retired = vi.fn(async () => undefined);
+ const prepare = vi.fn<NonNullable<typeof deps.prepareCodexExtraSpawnConfig>>(async () => ({
+ extraArgs: [], extraEnv: {}, requiredSpawnCredentialMode: 'oauth-bearer', onHostRetired: retired,
+ }));
+ deps.prepareCodexExtraSpawnConfig = prepare;
+ const agent = new CodexAgent(deps);
+ try {
+ await expect(agent.startSession({ sessionId: 'conflicting-spawn', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' })).rejects.toThrow('requires official OAuth');
+ expect(prepare).toHaveBeenCalledOnce();
+ expect(retired).toHaveBeenCalledOnce();
+ expect(createdTransports).toHaveLength(0);
+ } finally {
+ await agent.dispose();
+ }
+ });
+
+ it('does not infer isolated storage from an unrelated custom route catalog', async () => {
+ const agent = new CodexAgent(createDeps({}, {
+ prepareCodexExtraSpawnConfig: async () => ({
+ extraArgs: [], extraEnv: {}, codexProxyActive: true,
+ codexCustomProviderRoutes: [{ providerId: 'cprov-unrelated', modelProviderId: 'custom', capabilities: {}, responseModels: ['gpt-5.4'] }],
+ }),
+ }));
+ try {
+ await agent.startSession({ sessionId: 'legacy', model: 'gpt-5.4', workingDir: '/repo' });
+ expect(createdStdioOptions[0]?.extraArgs).not.toContain('cli_auth_credentials_store="ephemeral"');
+ } finally {
+ await agent.dispose();
+ }
+ });
+});
+
describe('CodexAgent spawn configuration', () => {
it('holds account session recovery until the MCP bridge replacement is ready', async () => {
let endpoint = 'http://127.0.0.1:51359/mcp/cindy_scheduler';
@@ -2050,11 +2578,11 @@ describe('CodexAgent capability routing', () => {
const hosts = (agent as unknown as { hosts: Map<string, unknown> }).hosts;
let displacedHost: unknown;
MockCodexTransport.beforeSkillsListResponse = () => {
- displacedHost = hosts.get('local-control:provider-oauth');
+ displacedHost = hosts.get('local-control:provider-oauth:external-auth');
const sessionHost = hosts.get('local');
expect(displacedHost).toBeDefined();
expect(sessionHost).toBeDefined();
- hosts.set('local-control:provider-oauth', sessionHost);
+ hosts.set('local-control:provider-oauth:external-auth', sessionHost);
};
await expect(agent.startSession({
@@ -2066,7 +2594,7 @@ describe('CodexAgent capability routing', () => {
'Codex Skill discovery expired because its control-plane app-server was replaced',
);
- if (displacedHost) hosts.set('local-control:provider-oauth', displacedHost);
+ if (displacedHost) hosts.set('local-control:provider-oauth:external-auth', displacedHost);
await agent.dispose();
});
@@ -8837,6 +9365,7 @@ describe('CodexAgent MCP thread context hooks', () => {
})).rejects.toThrow(/still attached/i);
expect(prepareCodexLocalCredentialModeSwitch).toHaveBeenCalledWith({
+ hostKey: 'local',
fromMode: 'oauth-bearer',
fromModeEffective: 'oauth-bearer',
toMode: 'oauth-bearer',
@@ -9022,6 +9551,7 @@ describe('CodexAgent MCP thread context hooks', () => {
});
expect(prepareCodexLocalCredentialModeSwitch).toHaveBeenCalledWith({
+ hostKey: 'local',
fromMode: 'gateway-key',
fromModeEffective: 'gateway-key',
toMode: 'oauth-bearer',
@@ -9065,6 +9595,7 @@ describe('CodexAgent MCP thread context hooks', () => {
});
expect(prepareCodexLocalCredentialModeSwitch).toHaveBeenCalledWith({
+ hostKey: 'local',
fromMode: 'gateway-key',
fromModeEffective: 'gateway-key',
toMode: 'oauth-bearer',
@@ -9176,6 +9707,7 @@ describe('CodexAgent MCP thread context hooks', () => {
await expect(oauthStart).rejects.toThrow(/still attached/i);
expect(prepareCodexLocalCredentialModeSwitch).toHaveBeenCalledWith({
+ hostKey: 'local',
fromMode: 'gateway-key',
fromModeEffective: 'gateway-key',
toMode: 'oauth-bearer',
@@ -24036,7 +24568,7 @@ describe('CodexAgent.forkSdkSession', () => {
})).resolves.toMatchObject({ newSdkSessionId: 'child', usedNativeForkAnchor: true });
expect(host.request).toHaveBeenCalledWith(Method.ThreadFork, expect.objectContaining({
path: '/account-a/sessions/source.jsonl', lastTurnId: 'boundary',
- }));
+ }), expect.objectContaining({ beforeDispatch: expect.any(Function) }));
expect(recordCodexThreadLocation).toHaveBeenCalledWith('child', '/account-a', '/account-a/sessions/child.jsonl');
});
@@ -24057,7 +24589,7 @@ describe('CodexAgent.forkSdkSession', () => {
})).resolves.toMatchObject({ newSdkSessionId: 'fork-thread-id', usedNativeForkAnchor: true });
expect(host.request).toHaveBeenCalledWith(Method.ThreadFork, {
threadId: 'source', lastTurnId: 'failed-boundary', excludeTurns: true,
- });
+ }, { beforeDispatch: expect.any(Function) });
expect(host.request).not.toHaveBeenCalledWith(Method.ThreadRollback, expect.anything());
expect(host.unsubscribeThread).toHaveBeenCalledWith('fork-thread-id');
});
@@ -24205,6 +24737,8 @@ describe('CodexAgent.forkSdkSession', () => {
expect(host.getHost).toHaveBeenCalledWith(undefined, undefined, {
keyOverride: expect.stringMatching(/^local-fork:/),
+ routeIsCurrent: expect.any(Function),
+ routeSignal: expect.any(AbortSignal),
hostPurpose: 'control-plane',
});
expect(prepareCodexResumeSession).toHaveBeenCalledWith('source-thread-id');
@@ -24214,7 +24748,7 @@ describe('CodexAgent.forkSdkSession', () => {
lastTurnId: 'turn-at-boundary',
excludeTurns: true,
cwd: '/repo',
- });
+ }, { beforeDispatch: expect.any(Function) });
expect(host.request).not.toHaveBeenCalledWith(Method.ThreadRollback, expect.anything());
expect(host.unsubscribeThread).toHaveBeenCalledWith('fork-thread-id');
expect(retireHostKey).toHaveBeenCalledExactlyOnceWith(
@@ -24250,7 +24784,7 @@ describe('CodexAgent.forkSdkSession', () => {
threadId: 'imported-source-thread',
lastTurnId: 'turn-at-boundary',
excludeTurns: true,
- });
+ }, { beforeDispatch: expect.any(Function) });
});
it('uses the isolated rollback fallback when bounded native-turn fork is unavailable', async () => {
@@ -24267,7 +24801,7 @@ describe('CodexAgent.forkSdkSession', () => {
expect(host.request).toHaveBeenNthCalledWith(1, Method.ThreadFork, {
threadId: 'source-thread-id',
persistExtendedHistory: true,
- });
+ }, { beforeDispatch: expect.any(Function) });
expect(host.request).toHaveBeenNthCalledWith(2, Method.ThreadRollback, {
threadId: 'fork-thread-id',
numTurns: 1,
@@ -24382,7 +24916,7 @@ describe('CodexAgent.forkSdkSession', () => {
expect(order).toEqual(['prepare', 'fork']);
expect(host.request).toHaveBeenCalledWith(Method.ThreadFork, expect.objectContaining({
threadId: 'imported-source-thread',
- }));
+ }), { beforeDispatch: expect.any(Function) });
});
it('does not call thread/fork when source-thread preparation fails', async () => {
@@ -24418,7 +24952,7 @@ describe('CodexAgent.forkSdkSession', () => {
threadId: 'source-thread-id',
persistExtendedHistory: true,
cwd: '/repo',
- });
+ }, { beforeDispatch: expect.any(Function) });
expect(host.request).toHaveBeenNthCalledWith(2, Method.ThreadRollback, {
threadId: 'fork-thread-id',
numTurns: 2,
@@ -24445,7 +24979,7 @@ describe('CodexAgent.forkSdkSession', () => {
expect(host.request).toHaveBeenCalledWith(Method.ThreadFork, {
threadId: 'source-thread-id',
persistExtendedHistory: true,
- });
+ }, { beforeDispatch: expect.any(Function) });
expect(host.unsubscribeThread).toHaveBeenCalledTimes(1);
expect(host.unsubscribeThread).toHaveBeenCalledWith('fork-thread-id');
expect(host.unsubscribeThread).not.toHaveBeenCalledWith('source-thread-id');
@@ -24540,7 +25074,7 @@ describe('CodexAgent.forkSdkSession', () => {
threadId: 'source-thread-id',
persistExtendedHistory: true,
excludeTurns: true,
- });
+ }, { beforeDispatch: expect.any(Function) });
});
it('omits excludeTurns for daemons older than 0.145.0', async () => {
@@ -24582,7 +25116,7 @@ describe('CodexAgent.forkSdkSession', () => {
);
expect(host.request).toHaveBeenCalledWith(Method.ThreadFork, expect.objectContaining({
threadId: 'source-thread-id',
- }));
+ }), { beforeDispatch: expect.any(Function) });
});
it('inspects indexed source history without requiring the outgoing provider credentials', async () => {
@@ -24698,7 +25232,7 @@ describe('CodexAgent.forkSdkSession', () => {
expect(host.request).toHaveBeenCalledWith(
Method.ThreadFork,
expect.objectContaining({ path: sourceRollout }),
- );
+ { beforeDispatch: expect.any(Function) });
} finally {
await fs.rm(externalHome, { recursive: true, force: true });
}
@@ -33881,7 +34415,7 @@ describe('CodexAgent custom provider context window override', () => {
expect(host.getHost).toHaveBeenCalledWith(
undefined,
'provider-oauth',
- { ignoreBindingLeases: 1 },
+ { ignoreBindingLeases: 1, routeIsCurrent: expect.any(Function), routeSignal: expect.any(AbortSignal) },
);
await handle.close();
});
diff --git a/packages/maker-core/src/agents/codex/index.ts b/packages/maker-core/src/agents/codex/index.ts
index 4793fe7cbc..d9e6827975 100644
--- a/packages/maker-core/src/agents/codex/index.ts
+++ b/packages/maker-core/src/agents/codex/index.ts
@@ -194,7 +194,7 @@ import { CodexForkError, type CodexForkStage } from './fork-error.js';
import { resolveForkTurnAnchor } from './fork-turn-anchor.js';
import { parseReconnectAttemptMessage } from '../shared/network-error.js';
import { extractNonSecretErrorSignals } from '@cindy/maker-shared/error-redaction';
-import { AppServerHost, type ThreadEventHandlers, type ThreadSubscription } from './app-server/host.js';
+import { AppServerHost, CodexNativeInitializationStoppedError, type ThreadEventHandlers, type ThreadSubscription } from './app-server/host.js';
import { AppServerRequestTimeoutError } from './app-server/client.js';
import { useCodexHistoryHome, type CodexExternalAuth } from './app-server/external-auth.js';
import {
@@ -496,9 +496,52 @@ export function hostKey(remoteHostId?: string | null): string {
return remoteHostId ? `remote:${remoteHostId}` : 'local';
}
+/** Preserve legacy identities unless the concrete route excludes official OAuth. */
+export function codexLocalAuthHostIdentity(key: string, policy?: 'isolated' | 'legacy-shared'): string {
+ return policy === 'isolated' ? `${key}:external-auth` : key;
+}
+
+/** One identity calculation for initial creation, route reselection and writer handoff. */
+function localSessionHostIdentity(input: {
+ sessionId: string;
+ remoteHostId?: string;
+ accountSessionHost: boolean;
+ accountProviderId?: string;
+ reviewMode: boolean;
+ customContext: boolean;
+ storage?: { sqliteHome: string; historyHome: string };
+ policy: 'isolated' | 'legacy-shared';
+}): string {
+ const base = input.accountSessionHost
+ ? `local-account:${input.accountProviderId ?? 'openai'}:session:${input.sessionId}`
+ : input.reviewMode ? localReviewHostKey(input.sessionId)
+ : input.customContext ? localCustomContextHostKey(input.sessionId) : hostKey(input.remoteHostId);
+ return codexLocalAuthHostIdentity(base + (input.storage
+ ? `:storage:${input.storage.sqliteHome}:history:${input.storage.historyHome}` : ''), input.policy);
+}
+
const LOCAL_CONTROL_PLANE_HOST_PREFIX = 'local-control:';
// One bridge is shared by every local host, including account and utility hosts.
const LOCAL_MCP_REFRESH_KEY = 'local-mcp-refresh';
+const LOCAL_CONFIGURATION_CHANGE_KEY = LOCAL_MCP_REFRESH_KEY;
+// Only raised before a caller sends a thread RPC; safe to select a fresh route.
+class CodexRouteSelectionChangedError extends Error {
+ constructor(message = 'Codex route changed during startup', readonly retryable = true) { super(message); }
+}
+
+async function awaitCodexRouteSelection<T>(pending: Promise<T>, signal?: AbortSignal): Promise<T> {
+ if (!signal) return pending;
+ signal.throwIfAborted();
+ return new Promise<T>((resolve, reject) => {
+ const abort = () => {
+ signal.removeEventListener('abort', abort);
+ reject(signal.reason);
+ };
+ signal.addEventListener('abort', abort, { once: true });
+ void pending.then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
+ });
+}
+
const CODEX_MODEL_LIST_RPC_TIMEOUT_MS = 20_000;
const CODEX_MODEL_REFRESH_DEADLINE_MS = 20_000;
@@ -1967,6 +2010,8 @@ export class CodexAgent extends BaseAgent {
generation: number;
promise: Promise<void> | null;
}>();
+ // Keep exact-process exit evidence even after its reusable registry entry is gone.
+ private hostRetirementResults = new WeakMap<AppServerHost, Promise<void>>();
/**
* app-server 启动时返回的 $CODEX_HOME 绝对路径 (InitializeResponse.codexHome)。
@@ -2228,10 +2273,11 @@ export class CodexAgent extends BaseAgent {
}
}
- private async waitForHostCredentialModeSwitch(key: string): Promise<void> {
+ private async waitForHostCredentialModeSwitch(key: string, skipConfigurationGuard = false): Promise<void> {
while (true) {
- const switching = this.hostCredentialModeSwitches.get(LOCAL_MCP_REFRESH_KEY)
- ?? this.hostCredentialModeSwitches.get(key);
+ const switching = (!skipConfigurationGuard && !key.startsWith('remote:')
+ ? this.hostCredentialModeSwitches.get(LOCAL_CONFIGURATION_CHANGE_KEY)
+ : undefined) ?? this.hostCredentialModeSwitches.get(key);
if (!switching) return;
await switching.catch(() => undefined);
}
@@ -2239,7 +2285,7 @@ export class CodexAgent extends BaseAgent {
async beginLocalHostCredentialChange(
reason = 'CodexAgent local credential state changed',
- options: { allLocalHosts?: boolean; busyError?: () => Error } = {},
+ options: { allLocalHosts?: boolean; forceRetire?: boolean; busyError?: () => Error } = {},
): Promise<{
assertIdle(): void;
retireActiveHost(): Promise<void>;
@@ -2257,6 +2303,7 @@ export class CodexAgent extends BaseAgent {
if (pending.length === 0) break;
await Promise.allSettled(pending);
}
+ this.bumpHostGeneration(LOCAL_CONFIGURATION_CHANGE_KEY);
let releaseSwitch!: () => void;
const switchPromise = new Promise<void>((resolve) => {
@@ -2291,7 +2338,7 @@ export class CodexAgent extends BaseAgent {
const retire = async (): Promise<void> => {
for (const candidate of affectedKeys()) {
await this.retireHostKey(candidate, reason, {
- failIfActive: options.allLocalHosts === true,
+ failIfActive: options.allLocalHosts === true && options.forceRetire !== true,
logPrefix: 'codex local credential hard cut',
throwOnShutdownFailure: true,
});
@@ -2317,7 +2364,7 @@ export class CodexAgent extends BaseAgent {
try {
if (!hostRetired) {
if (options.allLocalHosts) {
- if (activeUseCount() > 0) throw options.busyError?.() ?? new Error('Cannot refresh MCP while local Codex hosts are active or starting');
+ if (!options.forceRetire && activeUseCount() > 0) throw options.busyError?.() ?? new Error('Cannot refresh MCP while local Codex hosts are active or starting');
await retire();
} else {
await this.disposeLocalHostForCredentialChangeUnlocked(key, reason);
@@ -2353,6 +2400,7 @@ export class CodexAgent extends BaseAgent {
const coordinator = this.deps.prepareCodexLocalCredentialModeSwitch;
if (coordinator) {
await coordinator({
+ hostKey: key,
fromMode: currentMode,
fromModeEffective: currentEffective,
toMode,
@@ -2396,12 +2444,39 @@ export class CodexAgent extends BaseAgent {
}
}
+ private routeResolutionAbort = new AbortController();
+
+ private async resolveLocalAuthSelection(providerId: string | null | undefined, model: string) {
+ const signal = this.routeResolutionAbort.signal;
+ for (let attempt = 0; ; attempt++) {
+ signal.throwIfAborted();
+ await awaitCodexRouteSelection(this.waitForHostCredentialModeSwitch(LOCAL_CONFIGURATION_CHANGE_KEY), signal);
+ signal.throwIfAborted();
+ const generation = this.hostGenerations.get(LOCAL_CONFIGURATION_CHANGE_KEY);
+ const resolved = await awaitCodexRouteSelection(
+ Promise.resolve(this.deps.resolveCodexLocalAuthPolicy?.(providerId, model, signal) ?? 'legacy-shared'), signal,
+ );
+ signal.throwIfAborted();
+ const policy = typeof resolved === 'string' ? resolved : resolved.policy;
+ const isCurrent = () => !signal.aborted
+ && generation === this.hostGenerations.get(LOCAL_CONFIGURATION_CHANGE_KEY)
+ && !this.hostCredentialModeSwitches.has(LOCAL_CONFIGURATION_CHANGE_KEY)
+ && (typeof resolved === 'string' || resolved.isCurrent());
+ if (isCurrent()) return { policy, isCurrent };
+ if (attempt >= 7) throw new CodexRouteSelectionChangedError('Codex route changed repeatedly during selection', false);
+ }
+ }
+
private async getHost(
remoteHostId?: string,
credentialMode?: AgentCredentialMode,
opts: {
providerId?: string;
ignoreBindingLeases?: number;
+ routeIsCurrent?: () => boolean;
+ routeSignal?: AbortSignal;
+ reuseExistingUtilityHost?: boolean;
+ localAuthPolicy?: 'isolated' | 'legacy-shared';
keyOverride?: string;
hostPurpose?: 'control-plane' | 'review' | 'custom-context';
customContextModel?: string;
@@ -2411,6 +2486,9 @@ export class CodexAgent extends BaseAgent {
} = {},
): Promise<AppServerHost> {
const key = opts.keyOverride ?? (opts.providerId ? `local-account:${opts.providerId}` : hostKey(remoteHostId));
+ const assertRouteCurrent = (): void => {
+ if (opts.routeIsCurrent && !opts.routeIsCurrent()) throw new CodexRouteSelectionChangedError();
+ };
// spawnMode = 调用方原始诉求(undefined 保持 adapter fallback,spawn 行为不变)。
// 复用判定分两级(review P2:归一化解析走 getState、含 reconcile/fs,不允许进
// 无条件路径):
@@ -2466,7 +2544,8 @@ export class CodexAgent extends BaseAgent {
return true;
};
while (true) {
- if (!remoteHostId) await this.waitForHostCredentialModeSwitch(key);
+ if (!remoteHostId) await awaitCodexRouteSelection(this.waitForHostCredentialModeSwitch(key), opts.routeSignal);
+ assertRouteCurrent();
const retiring = this.retiringHosts.get(key);
if (retiring) {
await this.beginHostRetirement(key, retiring.host, 'recheck retirement before Host reuse');
@@ -2475,6 +2554,8 @@ export class CodexAgent extends BaseAgent {
const existing = this.hosts.get(key);
if (existing) {
+ // Preserve getUtilityHost's reuse semantics if a switch finished while it awaited getHost.
+ if (opts.reuseExistingUtilityHost) return existing;
const currentMode = this.hostCredentialModes.get(key);
const currentEffective = this.hostEffectiveCredentialModes.get(key);
const subagentRoutingProfileCompatible = remoteHostId
@@ -2489,6 +2570,7 @@ export class CodexAgent extends BaseAgent {
) {
if (this.hosts.get(key) !== existing || this.retiringHosts.has(key)
|| (!remoteHostId && this.hostCredentialModeSwitches.has(LOCAL_MCP_REFRESH_KEY))) continue;
+assertRouteCurrent();
return existing;
}
await this.shutdownHostForCredentialModeChange(
@@ -2506,6 +2588,10 @@ export class CodexAgent extends BaseAgent {
const inflight = this.hostPromises.get(key);
if (inflight) {
+ if (opts.reuseExistingUtilityHost) {
+ await inflight.promise;
+ continue;
+ }
// inflight 的归一化形态要等 createHost 内 getState 完成才知道,这里按
// undefined(保守)参与仲裁:跨形态请求会走重建,与改动前语义一致。
// in-flight host 还不知道 codexProxyActive。provider-oauth 只复用同为 provider-oauth
@@ -2553,6 +2639,7 @@ export class CodexAgent extends BaseAgent {
) {
if (this.hosts.get(key) !== inflightHost || this.retiringHosts.has(key)
|| this.hostCredentialModeSwitches.has(LOCAL_MCP_REFRESH_KEY)) continue;
+assertRouteCurrent();
return inflightHost;
}
continue;
@@ -2590,6 +2677,7 @@ export class CodexAgent extends BaseAgent {
if (this.retiringHosts.has(key) || this.hosts.has(key) || this.hostPromises.has(key)) continue;
if (!remoteHostId && this.hostCredentialModeSwitches.has(LOCAL_MCP_REFRESH_KEY)) continue;
+ assertRouteCurrent();
const generation = this.bumpHostGeneration(key);
// 超集归一化发生在 createHost 内(gateway-key → oauth-bearer);通过回调同步
// in-flight 登记,让并发的 oauth-bearer 诉求命中复用而不是 supersede 重建。
@@ -2616,6 +2704,8 @@ export class CodexAgent extends BaseAgent {
opts.providerId,
opts.sqliteHome,
opts.historyHome,
+ opts.localAuthPolicy,
+ opts.routeIsCurrent,
).finally(() => {
// 成功: this.hosts 已赋值, 后续走快路径; 失败: 清掉 promise 让下次调用能重试
const current = this.hostPromises.get(key);
@@ -2631,6 +2721,7 @@ export class CodexAgent extends BaseAgent {
const host = await promise;
if (this.hosts.get(key) !== host || this.retiringHosts.has(key)
|| (!remoteHostId && this.hostCredentialModeSwitches.has(LOCAL_MCP_REFRESH_KEY))) continue;
+assertRouteCurrent();
return host;
}
}
@@ -2683,7 +2774,7 @@ export class CodexAgent extends BaseAgent {
const existing = this.hosts.get(key);
if (existing) return { key, host: existing };
const inflight = this.hostPromises.get(key);
- if (!inflight) return { key, host: await this.getHost() };
+ if (!inflight) return { key, host: await this.getHost(undefined, undefined, { reuseExistingUtilityHost: true }) };
const host = await inflight.promise;
if (this.hosts.get(key) !== host || this.retiringHosts.has(key)) continue;
return { key, host };
@@ -2734,7 +2825,10 @@ export class CodexAgent extends BaseAgent {
const credentialMode = options?.credentialMode;
if (!credentialMode) return this.refreshLocalModelsWithinDeadline(options);
- const key = options?.providerId ? `local-account:${options.providerId}:models` : localControlPlaneHostKey(credentialMode);
+ const key = codexLocalAuthHostIdentity(
+ options?.providerId ? `local-account:${options.providerId}:models` : localControlPlaneHostKey(credentialMode),
+ credentialMode === 'gateway-key' ? 'isolated' : 'legacy-shared',
+ );
let timer: ReturnType<typeof setTimeout> | undefined;
const deadline = new Promise<never>((_, reject) => {
timer = setTimeout(() => {
@@ -2765,14 +2859,17 @@ export class CodexAgent extends BaseAgent {
const credentialMode = options?.credentialMode;
// 显式 provider 刷新使用独立 control-plane app-server。不能为了发一次 model/list
// 切换共享 local host 的凭证形态:切换协调器会关闭空闲会话,忙碌会话则直接拒绝。
- const key = options?.providerId ? `local-account:${options.providerId}:models` : credentialMode
- ? localControlPlaneHostKey(credentialMode)
- : hostKey();
+ const key = codexLocalAuthHostIdentity(
+ options?.providerId ? `local-account:${options.providerId}:models` : credentialMode
+ ? localControlPlaneHostKey(credentialMode) : hostKey(),
+ credentialMode === 'gateway-key' ? 'isolated' : 'legacy-shared',
+ );
return this.withHostOperation(async () => ({
key: credentialMode ? key : hostKey(),
host: credentialMode
? await this.getHost(undefined, credentialMode, {
providerId: options?.providerId,
+ ...(credentialMode === 'gateway-key' ? { localAuthPolicy: 'isolated' as const } : {}),
keyOverride: key,
hostPurpose: 'control-plane',
})
@@ -2854,6 +2951,8 @@ export class CodexAgent extends BaseAgent {
providerId?: string,
sqliteHome?: string,
historyHome?: string,
+ localAuthPolicy?: 'isolated' | 'legacy-shared',
+ routeIsCurrent?: () => boolean,
): Promise<AppServerHost> {
const seq = (this.createHostSeqByKey.get(key) ?? 0) + 1;
this.createHostSeqByKey.set(key, seq);
@@ -2871,6 +2970,7 @@ export class CodexAgent extends BaseAgent {
generation,
});
const assertCurrentGeneration = (stage: string): void => {
+ if (routeIsCurrent && !routeIsCurrent()) throw new CodexRouteSelectionChangedError();
if ((this.hostGenerations.get(key) ?? 0) === generation) return;
throw new Error(`Codex app-server host creation was superseded before ${stage}`);
};
@@ -2879,7 +2979,7 @@ export class CodexAgent extends BaseAgent {
// 同时还能服务订阅会话 —— 订阅/API 会话真正并行,不再因来源切换重建 host 排队。
let spawnCredentialMode = credentialMode;
let requestedGatewayState: AuthState | null = null;
- if (!remoteHostId && credentialMode === 'gateway-key') {
+ if (!remoteHostId && localAuthPolicy !== 'isolated' && credentialMode === 'gateway-key') {
// 即使升格为 OAuth spawn,API 会话的出口仍依赖 gateway key,必须先验证原诉求。
requestedGatewayState = await this.deps.auth.getState({ credentialMode: 'gateway-key' });
assertCurrentGeneration('gateway credential validation');
@@ -2976,6 +3076,9 @@ export class CodexAgent extends BaseAgent {
...(!remoteHostId && historyHome ? { runtimeCodexHome: historyHome } : {}),
...(key.startsWith('local-account:') ? { accountHostKey: `${key}:${generation}` } : {}),
credentialMode: spawnCredentialMode,
+ ...(localAuthPolicy === 'isolated'
+ ? { localAuthPolicy, hostScopeKey: `${key}:${generation}` }
+ : {}),
...(spawnCredentialMode !== credentialMode
? { requestedCredentialMode: credentialMode }
: {}),
@@ -3003,6 +3106,9 @@ export class CodexAgent extends BaseAgent {
});
await hostRetirementCleanup?.();
hostRetirementCleanup = undefined;
+ if (localAuthPolicy === 'isolated') {
+ throw Object.assign(new Error('Codex route requires official OAuth on an external-auth host'), { codexSpawnConfigFatal: true });
+ }
spawnCredentialMode = cfg.requiredSpawnCredentialMode;
continue;
}
@@ -3042,6 +3148,7 @@ export class CodexAgent extends BaseAgent {
} catch (e) {
await hostRetirementCleanup?.();
hostRetirementCleanup = undefined;
+ if (e instanceof CodexRouteSelectionChangedError) throw e;
const isFatalSpawnConfigError =
(typeof e === 'object' && e !== null &&
(e as { codexSpawnConfigFatal?: unknown }).codexSpawnConfigFatal === true);
@@ -3073,7 +3180,8 @@ export class CodexAgent extends BaseAgent {
}
if (!remoteHostId && sqliteHome) extraArgs.push('-c', `sqlite_home=${JSON.stringify(sqliteHome)}`);
let externalAuth: CodexExternalAuth | undefined;
- const requireEphemeralAuth = !remoteHostId && !!historyHome && path.resolve(historyHome) !== path.resolve(env.CODEX_HOME ?? '');
+ const requireEphemeralAuth = !remoteHostId && (localAuthPolicy === 'isolated'
+ || (!!historyHome && path.resolve(historyHome) !== path.resolve(env.CODEX_HOME ?? '')));
if (!remoteHostId && hostPurpose === 'control-plane' && effectiveMode === 'oauth-bearer' && env.CODEX_HOME) {
// Managed refresh must read the selected account's file, not an inherited identity.
env = useCodexHistoryHome(env, env.CODEX_HOME);
@@ -3082,7 +3190,7 @@ export class CodexAgent extends BaseAgent {
// Extra spawn configuration above intentionally uses the TARGET credential
// home (proxy auth, model catalogs and account controls). Only the native
// runtime uses the canonical history home, including lineage/writer locks.
- env = useCodexHistoryHome(env, historyHome!);
+ env = useCodexHistoryHome(env, historyHome ?? env.CODEX_HOME);
extraArgs.push('-c', 'cli_auth_credentials_store="ephemeral"');
if (effectiveMode === 'oauth-bearer') {
if (!readAccountTokens) {
@@ -3188,7 +3296,7 @@ export class CodexAgent extends BaseAgent {
// 持续撞鉴权失败; auth.invalidate 会触发 logout + 通知 UI 重登。延后到 microtask
// 防止在 JSON-RPC response 分发回调里同步收割自己。远端也走同一结构化协议路径。
onAuthInvalidated: (reason) => {
- const usesLocalAuth = !remoteHostId;
+ const usesLocalAuth = !remoteHostId && localAuthPolicy !== 'isolated';
this.deps.logger.warn('codex auth invalidated', {
reason,
key,
@@ -3400,20 +3508,37 @@ export class CodexAgent extends BaseAgent {
}
async startSession(opts: StartSessionOptions): Promise<AgentSessionHandle> {
- const startupCleanup: { customContext?: () => Promise<void> } = {};
- try {
- return await this.startSessionInternal(opts, (cleanup) => {
- startupCleanup.customContext = cleanup ?? undefined;
- });
- } catch (error) {
- await startupCleanup.customContext?.();
- throw error;
+ const signal = this.routeResolutionAbort.signal;
+ for (let attempt = 0; ; attempt++) {
+ const startup = {
+ signal, threadDispatched: false,
+ cleanup: undefined as (() => Promise<void>) | undefined,
+ customContext: undefined as (() => Promise<void>) | undefined,
+ };
+ try {
+ signal.throwIfAborted();
+ return await this.startSessionInternal(opts, (cleanup) => {
+ startup.customContext = cleanup ?? undefined;
+ }, startup);
+ } catch (error) {
+ if (!startup.threadDispatched
+ && (error instanceof CodexRouteSelectionChangedError || error instanceof CodexNativeInitializationStoppedError || signal.aborted)) {
+ // No thread was submitted. Release this startup's lease and retire only
+ // an unused host; another live handle's process belongs to that handle.
+ await startup.cleanup?.();
+ if (!signal.aborted && error instanceof CodexRouteSelectionChangedError && error.retryable && attempt < 7) continue;
+ throw new AgentStartupStoppedError(signal.aborted ? signal.reason : error);
+ }
+ await startup.customContext?.();
+ throw error;
+ }
}
}
private async startSessionInternal(
opts: StartSessionOptions,
registerFailedCustomContextStartupCleanup: (cleanup: (() => Promise<void>) | null) => void,
+ startup: { signal: AbortSignal; threadDispatched: boolean; cleanup?: () => Promise<void> },
): Promise<AgentSessionHandle> {
// scope 带完整 s:<sessionId> 前缀 → host logger 落盘时提取 business sessionId,
// 路由到 sessions/<id>/<date>.ndjson (logger.ts extractSessionId / sessionAgentSlot)。
@@ -4782,15 +4907,22 @@ export class CodexAgent extends BaseAgent {
const accountProviderId = this.deps.isCodexAccountProvider?.(opts.providerId) ? opts.providerId! : undefined;
const accountSessionHost = !opts.remoteHostId && (accountProviderId !== undefined || this.deps.isolateCodexAccountSessions === true);
if (opts.remoteHostId && accountProviderId) throw new Error('This Codex account belongs to the local device');
- const credentialMode = opts.remoteHostId
+ const startupRouteSignal = this.routeResolutionAbort.signal;
+ let routeSelection = opts.remoteHostId
+ ? { policy: 'legacy-shared' as const, isCurrent: () => true }
+ : await this.resolveLocalAuthSelection(opts.providerId, opts.model);
+ const requestedCredentialMode = opts.remoteHostId
? undefined
: accountProviderId ? 'oauth-bearer' : resolveAgentCredentialMode({
agentKind: 'codex',
providerId: opts.providerId,
model: opts.model,
});
+ let localAuthPolicy = routeSelection.policy;
+ let credentialMode = requestedCredentialMode
+ ?? (localAuthPolicy === 'isolated' ? 'provider-oauth' : undefined);
const resolveCodexThreadContextWindow = this.deps.resolveCodexThreadContextWindow;
- const initialCustomContextWindow = !reviewMode
+ let initialCustomContextWindow = !reviewMode
? await resolveCodexThreadContextWindow?.(opts.providerId, opts.model) ?? null
: null;
const customContextCatalogIdentity = (
@@ -4800,13 +4932,13 @@ export class CodexAgent extends BaseAgent {
typeof contextWindow === 'number' && Number.isFinite(contextWindow) && contextWindow > 0
? `${model}\0${Math.floor(contextWindow)}`
: null;
- const initialCustomContextCatalogIdentity = customContextCatalogIdentity(
+ let initialCustomContextCatalogIdentity = customContextCatalogIdentity(
opts.model,
initialCustomContextWindow,
);
// SSH shares a daemon across tasks; its context settings belong to each
// thread/start or thread/resume config, never a local single-session host.
- const usesCustomContextHost = !opts.remoteHostId && initialCustomContextCatalogIdentity !== null;
+ let usesCustomContextHost = !opts.remoteHostId && initialCustomContextCatalogIdentity !== null;
const resolveModelSwitchCatalogIdentity = async (
newModel: string,
setOpts?: { providerId?: string | null },
@@ -4824,20 +4956,29 @@ export class CodexAgent extends BaseAgent {
setOpts?: { providerId?: string | null },
): Promise<boolean> => {
const nextProvider = setOpts && Object.hasOwn(setOpts, 'providerId') ? setOpts.providerId : mutableProviderId;
- return (this.deps.isCodexAccountProvider?.(nextProvider) ? nextProvider : undefined) !== accountProviderId ||
- (await resolveModelSwitchCatalogIdentity(newModel, setOpts)) !== initialCustomContextCatalogIdentity;
- };
- const baseSessionHostKey = reviewMode
- ? localReviewHostKey(sid)
- : usesCustomContextHost
- ? localCustomContextHostKey(sid)
- : hostKey(opts.remoteHostId);
+ if ((this.deps.isCodexAccountProvider?.(nextProvider) ? nextProvider : undefined) !== accountProviderId) return true;
+ for (let attempt = 0; ; attempt++) {
+ const selection = opts.remoteHostId ? null : await this.resolveLocalAuthSelection(
+ setOpts && Object.hasOwn(setOpts, 'providerId') ? setOpts.providerId : mutableProviderId,
+ newModel,
+ );
+ const catalogIdentity = await resolveModelSwitchCatalogIdentity(newModel, setOpts);
+ if (!selection || selection.isCurrent()) {
+ return catalogIdentity !== initialCustomContextCatalogIdentity
+ || (selection !== null && selection.policy !== localAuthPolicy);
+ }
+ if (attempt >= 7) throw new CodexRouteSelectionChangedError('Codex route changed repeatedly during model switch');
+ }
+ };
const sessionStorage = !opts.remoteHostId && opts.resumeSessionId
? await this.deps.resolveCodexThreadStorage?.(opts.resumeSessionId)
: undefined;
const sessionSqliteHome = sessionStorage?.sqliteHome;
- const currentHostKey = (accountSessionHost ? `local-account:${accountProviderId ?? 'openai'}:session:${sid}` : baseSessionHostKey)
- + (sessionStorage ? `:storage:${sessionSqliteHome}:history:${sessionStorage.historyHome}` : '');
+ const resolveSessionHostKey = (): string => localSessionHostIdentity({
+ sessionId: sid, remoteHostId: opts.remoteHostId, accountSessionHost, accountProviderId,
+ reviewMode, customContext: usesCustomContextHost, storage: sessionStorage, policy: localAuthPolicy,
+ });
+ let currentHostKey = resolveSessionHostKey();
let releaseHostBindingLease: (() => void) | null = null;
const acquireHostBindingLeaseIfNeeded = (): void => {
if (opts.remoteHostId || releaseHostBindingLease) return;
@@ -4852,10 +4993,9 @@ export class CodexAgent extends BaseAgent {
if (opts.remoteHostId) return await this.getHost(opts.remoteHostId, credentialMode);
// 本地会话先等已有 credential switch 完成,再占用 startup reservation。否则
// session 已拿到旧 host、但尚未 thread/start 订阅时,credential 切换看不到它。
- do {
- await this.waitForHostCredentialModeSwitch(currentHostKey);
- } while (this.hostCredentialModeSwitches.has(LOCAL_MCP_REFRESH_KEY)
- || this.hostCredentialModeSwitches.has(currentHostKey));
+ await awaitCodexRouteSelection(this.waitForHostCredentialModeSwitch(currentHostKey), startupRouteSignal);
+ startupRouteSignal.throwIfAborted();
+ if (!routeSelection.isCurrent()) throw new CodexRouteSelectionChangedError();
acquireHostBindingLeaseIfNeeded();
return await this.getHost(opts.remoteHostId, credentialMode, {
...(accountProviderId ? { providerId: accountProviderId } : {}),
@@ -4863,6 +5003,12 @@ export class CodexAgent extends BaseAgent {
...(sessionStorage ? { historyHome: sessionStorage.historyHome } : {}),
...(accountSessionHost || reviewMode || usesCustomContextHost || sessionSqliteHome ? { keyOverride: currentHostKey } : {}),
ignoreBindingLeases: 1,
+ routeIsCurrent: routeSelection.isCurrent,
+ routeSignal: startupRouteSignal,
+ ...(localAuthPolicy === 'isolated' || reviewMode || usesCustomContextHost
+ ? { keyOverride: currentHostKey }
+ : {}),
+ ...(localAuthPolicy === 'isolated' ? { localAuthPolicy } : {}),
...(reviewMode
? { hostPurpose: 'review' as const }
: usesCustomContextHost
@@ -4874,10 +5020,28 @@ export class CodexAgent extends BaseAgent {
: {}),
});
};
- const host = await getSessionHost().catch((error) => {
- releaseHostBindingLeaseIfNeeded();
- throw error;
- });
+ const host = await (async () => {
+ for (let attempt = 0; ; attempt++) {
+ try {
+ return await getSessionHost();
+ } catch (error) {
+ releaseHostBindingLeaseIfNeeded();
+ startupRouteSignal.throwIfAborted();
+ if (!(error instanceof CodexRouteSelectionChangedError)) throw error;
+ if (!error.retryable || attempt >= 7) {
+ throw new CodexRouteSelectionChangedError('Codex route changed repeatedly during host preparation', false);
+ }
+ routeSelection = await this.resolveLocalAuthSelection(opts.providerId, opts.model);
+ localAuthPolicy = routeSelection.policy;
+ credentialMode = requestedCredentialMode ?? (localAuthPolicy === 'isolated' ? 'provider-oauth' : undefined);
+ initialCustomContextWindow = !reviewMode
+ ? await resolveCodexThreadContextWindow?.(opts.providerId, opts.model) ?? null : null;
+ initialCustomContextCatalogIdentity = customContextCatalogIdentity(opts.model, initialCustomContextWindow);
+ usesCustomContextHost = initialCustomContextCatalogIdentity !== null;
+ currentHostKey = resolveSessionHostKey();
+ }
+ }
+ })();
const hostGeneration = this.hostGenerations.get(currentHostKey) ?? 0;
const capturedHostWasRegistered = this.hosts.get(currentHostKey) === host;
const retireSingleSessionHost = async (): Promise<void> => {
@@ -4903,6 +5067,17 @@ export class CodexAgent extends BaseAgent {
await retireSingleSessionHost();
});
}
+ startup.cleanup = async () => {
+ releaseHostBindingLeaseIfNeeded();
+ const retiring = this.retiringHosts.get(currentHostKey);
+ if (retiring?.host === host) await this.beginHostRetirement(currentHostKey, host, 'unsubmitted startup stopping');
+ if (this.hosts.get(currentHostKey) === host && this.hostActiveUseCount(currentHostKey, host) === 0) {
+ await this.retireHostKey(currentHostKey, 'Codex startup route changed before thread submission', {
+ failIfActive: true, logPrefix: 'codex unsubmitted startup cleanup',
+ expectedHost: host, expectedGeneration: hostGeneration, throwOnShutdownFailure: true,
+ });
+ }
+ };
const connectionId = host.getConnectionId();
// JSON-RPC IDs are connection-local (often 0). Desktop indexes interaction
// requests across sessions, so never expose a raw server ID as a UI ID.
@@ -4917,6 +5092,10 @@ export class CodexAgent extends BaseAgent {
const staleHostError = (operation: string): Error =>
new Error(`Codex session expired because its app-server was replaced before ${operation}; restart the session`);
const assertCurrentHost = (operation: string): void => {
+ if (!startup.threadDispatched) {
+ startup.signal.throwIfAborted();
+ if (!routeSelection.isCurrent()) throw new CodexRouteSelectionChangedError();
+ }
if (isCurrentHost()) return;
log.warn('codex session handle rejected after app-server replacement', {
operation,
@@ -4944,6 +5123,12 @@ export class CodexAgent extends BaseAgent {
assertCurrentHost('initialize');
} catch (error) {
releaseHostBindingLeaseIfNeeded();
+ // Exhaustion/cancellation of native startup is terminal for this request;
+ // a simultaneous route change must not multiply the three-process budget.
+ if (error instanceof CodexNativeInitializationStoppedError) throw error;
+ // A provider transaction may close initialize while no thread exists yet.
+ // Preserve route reselection instead of surfacing the transport's close error.
+ assertCurrentHost('initialize failed');
throw error;
}
const sessionCodexHome = initResp.codexHome ?? null;
@@ -5022,11 +5207,12 @@ export class CodexAgent extends BaseAgent {
const useLocalSkillDiscoveryHost =
!opts.remoteHostId && sessionCredentialMode === 'provider-oauth';
const skillDiscoveryHostKey = useLocalSkillDiscoveryHost
- ? localControlPlaneHostKey('provider-oauth')
+ ? codexLocalAuthHostIdentity(localControlPlaneHostKey('provider-oauth'), 'isolated')
: currentHostKey;
const skillDiscoveryHost = useLocalSkillDiscoveryHost
? await this.getHost(undefined, 'provider-oauth', {
keyOverride: skillDiscoveryHostKey,
+ localAuthPolicy: 'isolated',
hostPurpose: 'control-plane',
})
: host;
@@ -5073,6 +5259,7 @@ export class CodexAgent extends BaseAgent {
};
} catch (error) {
releaseHostBindingLeaseIfNeeded();
+ if (error instanceof CodexRouteSelectionChangedError) throw error;
throw new Error(
`Cannot start Codex safely because Cindy could not inspect restricted Codex Skills: ${error instanceof Error ? error.message : String(error)}`,
);
@@ -5184,6 +5371,7 @@ export class CodexAgent extends BaseAgent {
assertCurrentHost('Review capability isolation');
} catch (error) {
releaseHostBindingLeaseIfNeeded();
+ if (error instanceof CodexRouteSelectionChangedError) throw error;
throw new Error(
`Cannot start Codex Review safely because Cindy could not disable local Skills, plugins, and MCP servers: ${error instanceof Error ? error.message : String(error)}`,
);
@@ -5221,6 +5409,7 @@ export class CodexAgent extends BaseAgent {
}
} catch (error) {
releaseHostBindingLeaseIfNeeded();
+ if (error instanceof CodexRouteSelectionChangedError) throw error;
throw new Error(`Cannot prepare Codex Bot MCP configuration: ${error instanceof Error ? error.message : String(error)}`);
}
}
@@ -5251,6 +5440,7 @@ export class CodexAgent extends BaseAgent {
);
} catch (error) {
releaseHostBindingLeaseIfNeeded();
+ if (error instanceof CodexRouteSelectionChangedError) throw error;
throw new Error(`Cannot prepare local Skill configuration: ${error instanceof Error ? error.message : String(error)}`);
}
}
@@ -6555,9 +6745,16 @@ export class CodexAgent extends BaseAgent {
};
acquireHostBindingLeaseIfNeeded();
assertCurrentHost('thread/start');
- const resp = await withMcpDiscoveryContext(() => host.request<ThreadStartResponse>(Method.ThreadStart, params, {
- timeoutMs: CRITICAL_THREAD_RPC_TIMEOUT_MS,
- }));
+ const resp = await withMcpDiscoveryContext(() => {
+ assertCurrentHost('thread/start dispatch');
+ return host.request<ThreadStartResponse>(Method.ThreadStart, params, {
+ timeoutMs: CRITICAL_THREAD_RPC_TIMEOUT_MS,
+ beforeDispatch: () => {
+ assertCurrentHost('thread/start write');
+ startup.threadDispatched = true;
+ },
+ });
+ });
assertCurrentHost('thread/start');
if (Object.hasOwn(resp, 'serviceTier')) {
mutableServiceTier = normalizeServiceTier(resp.serviceTier) ?? null;
@@ -6657,9 +6854,16 @@ export class CodexAgent extends BaseAgent {
try {
acquireHostBindingLeaseIfNeeded();
assertCurrentHost('thread/resume');
- const resp = await withMcpDiscoveryContext(() => host.request<ThreadResumeResponse>(Method.ThreadResume, params, {
- timeoutMs: CRITICAL_THREAD_RPC_TIMEOUT_MS,
- }));
+ const resp = await withMcpDiscoveryContext(() => {
+ assertCurrentHost('thread/resume dispatch');
+ return host.request<ThreadResumeResponse>(Method.ThreadResume, params, {
+ timeoutMs: CRITICAL_THREAD_RPC_TIMEOUT_MS,
+ beforeDispatch: () => {
+ assertCurrentHost('thread/resume write');
+ startup.threadDispatched = true;
+ },
+ });
+ });
assertCurrentHost('thread/resume');
if (Object.hasOwn(resp, 'serviceTier')) {
mutableServiceTier = normalizeServiceTier(resp.serviceTier) ?? null;
@@ -6732,6 +6936,7 @@ export class CodexAgent extends BaseAgent {
serviceTier: mutableServiceTier ?? null,
});
} catch (e) {
+ if (!startup.threadDispatched && (e instanceof CodexRouteSelectionChangedError || startup.signal.aborted)) throw e;
let freshThreadStarted = false;
if (!preparedResumePath && (!indexedRolloutMissing || indexedThreadAbsent)
&& isExactNoRolloutThreadResumeError(e, opts.resumeSessionId)) {
@@ -6786,6 +6991,7 @@ export class CodexAgent extends BaseAgent {
await startFreshThread();
} catch (e) {
releaseHostBindingLeaseIfNeeded();
+ if (!startup.threadDispatched && (e instanceof CodexRouteSelectionChangedError || startup.signal.aborted)) throw e;
log.error('thread/start failed', { error: String(e) });
const message = `Failed to start Codex thread: ${String(e)}`;
eventQueue.push({
@@ -12695,6 +12901,7 @@ export class CodexAgent extends BaseAgent {
agentKind: 'codex',
get model() { return mutableModel; },
get codexProxyActive() { return hostUsesCodexProxy; },
+ get codexHostKey() { return currentHostKey; },
get codexThreadModelProviderId() { return codexThreadModelProviderId; },
get codexThreadMayHaveRollout() { return threadMayHaveRollout; },
get codexCindyRemoteCompactionCompatible() {
@@ -14380,6 +14587,71 @@ export class CodexAgent extends BaseAgent {
return bestPath;
}
+ async requiresCodexThreadHostTransfer(
+ opts: Parameters<BaseAgent['requiresCodexThreadHostTransfer']>[0],
+ ): Promise<boolean> {
+ if (opts.remoteHostId) return false;
+ const observedHosts = new Set<AppServerHost>();
+ for (let attempt = 0; attempt < 8; attempt += 1) {
+ const hosts = new Map([...this.hosts].filter(([key]) => key.startsWith('local')));
+ const generations = new Map([...this.hostGenerations].filter(([key]) => key.startsWith('local')));
+ const writerCandidates = new Map([...hosts.values()].map((host) => [host, host.writerCandidate]));
+ for (const host of hosts.values()) observedHosts.add(host);
+ const registryCurrent = () => {
+ const currentHosts = [...this.hosts].filter(([key]) => key.startsWith('local'));
+ const currentGenerations = [...this.hostGenerations].filter(([key]) => key.startsWith('local'));
+ return currentHosts.length === hosts.size && currentGenerations.length === generations.size
+ && currentHosts.every(([key, host]) => hosts.get(key) === host && writerCandidates.get(host) === host.writerCandidate)
+ && currentGenerations.every(([key, generation]) => generations.get(key) === generation);
+ };
+ const settleRetirements = async () => {
+ for (const [key, entry] of this.retiringHosts) {
+ if (key.startsWith('local')) observedHosts.add(entry.host);
+ }
+ // Do not retry a failed retirement here: callers must not commit a new
+ // route after a failed exit proof, even if the registry later changes.
+ await awaitCodexRouteSelection(Promise.all([...observedHosts].map((host) =>
+ this.hostRetirementResults.get(host))), this.routeResolutionAbort.signal);
+ };
+ await settleRetirements();
+ if (!registryCurrent()) continue;
+ const selection = await this.resolveLocalAuthSelection(opts.providerId, opts.model);
+ const contextWindow = opts.reviewMode ? null
+ : await this.deps.resolveCodexThreadContextWindow?.(opts.providerId, opts.model);
+ const accountProviderId = this.deps.isCodexAccountProvider?.(opts.providerId) ? opts.providerId! : undefined;
+ const storage = await this.deps.resolveCodexThreadStorage?.(opts.threadId);
+ const targetKey = localSessionHostIdentity({
+ sessionId: opts.sessionId ?? '', accountProviderId,
+ accountSessionHost: accountProviderId !== undefined || this.deps.isolateCodexAccountSessions === true,
+ reviewMode: opts.reviewMode === true,
+ customContext: typeof contextWindow === 'number' && Number.isFinite(contextWindow) && contextWindow > 0,
+ storage, policy: selection.policy,
+ });
+ if (!selection.isCurrent()) throw new CodexRouteSelectionChangedError();
+ for (const [key, host] of hosts) {
+ if (!registryCurrent()) break;
+ if (key === targetKey || !host.writerCandidate) continue;
+ let cursor: string | null = null;
+ do {
+ const result: { data: string[]; nextCursor?: string | null } | null = await awaitCodexRouteSelection(
+ host.request<{ data: string[]; nextCursor?: string | null }>('thread/loaded/list', { cursor }, { timeoutMs: CRITICAL_THREAD_RPC_TIMEOUT_MS }),
+ this.routeResolutionAbort.signal,
+ ).catch((error) => { if (!registryCurrent()) return null; throw error; });
+ if (!selection.isCurrent()) throw new CodexRouteSelectionChangedError();
+ if (!result || !registryCurrent()) break;
+ // A closed business handle does not release the native 0.153 writer.
+ if (result.data?.includes(opts.threadId)) return true;
+ cursor = result.nextCursor ?? null;
+ } while (cursor !== null);
+ }
+ await settleRetirements();
+ if (!registryCurrent()) continue;
+ if (!selection.isCurrent()) throw new CodexRouteSelectionChangedError();
+ return false;
+ }
+ throw new CodexRouteSelectionChangedError('Codex writer registry did not stabilize', false);
+ }
+
async forkSdkSession(opts: ForkSdkSessionOptions): Promise<ForkSdkSessionResult> {
const log = this.deps.logger.child('codex/fork');
const tailTurnsToDrop = normalizeTailTurnsToDrop(opts.tailTurnsToDrop);
@@ -14400,7 +14672,9 @@ export class CodexAgent extends BaseAgent {
// maxLineBytes 守卫后整条连接被熔断,当时共享 utility host 上挂着的 5 个活跃
// session 全部同时报错。fork 是离线控制面操作(不跑 turn、无订阅者),改用
// 唯一 key 的一次性 app-server:超限只让 fork 自己失败,不波及活跃任务。
- const forkHostKey = forkAccountId ? `local-account:${forkAccountId}:${localForkHostKey()}` : localForkHostKey();
+ const forkRouteSignal = this.routeResolutionAbort.signal;
+ const forkBaseHostKey = forkAccountId ? `local-account:${forkAccountId}:${localForkHostKey()}` : localForkHostKey();
+ let forkHostKey = forkBaseHostKey;
let releaseForkLease: (() => void) | undefined;
let forkHost: AppServerHost | undefined;
let forkHostRetired = false;
@@ -14464,78 +14738,105 @@ export class CodexAgent extends BaseAgent {
await assertCodexRolloutRewriteSupported(preparedSourcePath || await this.findRolloutPath(opts.sourceSdkSessionId));
historyChecked = true;
}
- // ID-only turn queries must use the source thread's index even when the
- // account supplying credentials has changed. Keep the child in that index.
const forkSqliteHome = forkStorage?.sqliteHome;
- stage = 'host-create';
- const leased = await this.acquireHostOperation(async () => {
- const host = await this.getHost(undefined, forkCredentialMode, {
- keyOverride: forkHostKey,
- ...(forkAccountId ? { providerId: forkAccountId } : {}),
- ...(forkSqliteHome ? { sqliteHome: forkSqliteHome } : {}),
- ...(forkStorage ? { historyHome: forkStorage.historyHome } : {}),
- hostPurpose: 'control-plane',
- }).catch((error) => {
- // This is the outgoing source's offline fork host, not a target send.
- // Missing old credentials must not trap a task on the provider it is leaving.
- if (opts.stripEncryptedReasoning && error instanceof AgentNotAuthenticatedError) {
- throw new CodexHistoryRecoveryRequiredError();
+ let forkCodexHome: string | undefined;
+ let forkDispatched = false;
+ const { host, resp, initResp, usedNativeForkAnchor } = await (async () => {
+ for (let attempt = 0; ; attempt++) {
+ forkRouteSignal.throwIfAborted();
+ const selection = await this.resolveLocalAuthSelection(opts.providerId, opts.model ?? '');
+ forkHostKey = codexLocalAuthHostIdentity(forkBaseHostKey, selection.policy);
+ forkHostRetired = false;
+ stage = 'host-create';
+ try {
+ const leased = await this.acquireHostOperation(async () => {
+ const host = await this.getHost(undefined, forkCredentialMode, {
+ keyOverride: forkHostKey,
+ ...(forkAccountId ? { providerId: forkAccountId } : {}),
+ ...(forkSqliteHome ? { sqliteHome: forkSqliteHome } : {}),
+ ...(forkStorage ? { historyHome: forkStorage.historyHome } : {}),
+ routeIsCurrent: selection.isCurrent,
+ routeSignal: forkRouteSignal,
+ ...(selection.policy === 'isolated' ? { localAuthPolicy: selection.policy } : {}),
+ hostPurpose: 'control-plane',
+ });
+ return { key: forkHostKey, host };
+ });
+ const { host } = leased;
+ releaseForkLease = leased.release;
+ forkHost = host;
+ stage = 'host-start';
+ const initResp = await host.ensureStarted();
+ // Child rollout discovery scans this.codexHome. The fork host may be
+ // the first host started by this process, so hydrate it here.
+ forkCodexHome = initResp.codexHome ?? undefined;
+ if (forkCodexHome && !forkAccountId && !forkStorage) this.codexHome = forkCodexHome;
+ // Imported Codex threads may still live under another CODEX_HOME. Resume
+ // already asks the desktop host to link/adopt their state and rollout;
+ // fork must cross the same preparation boundary before thread/fork or the
+ // fork app-server cannot resolve a freshly imported thread.
+ // A first host may have just created the managed state DB needed for imports.
+ stage = 'source-prepare';
+ preparedSourcePath ??= await this.deps.prepareCodexResumeSession?.(opts.sourceSdkSessionId);
+ if (opts.stripEncryptedReasoning && !historyChecked) {
+ // Check before allocating a child: indexed native history must go through
+ // Cindy's handoff recovery, never a file rewrite that invalidates Codex's DB.
+ await assertCodexRolloutRewriteSupported(preparedSourcePath || await this.findRolloutPath(opts.sourceSdkSessionId));
+ }
+ if (
+ !lastTurnId && (tailTurnsToDrop > 0 || opts.forkAtTimestampMs !== undefined) && !opts.stripEncryptedReasoning
+ && codexUserAgentAtLeast(initResp.userAgent, [0, 153, 4])
+ ) {
+ // Older/failed messages have no persisted UI anchor. Paginated threads
+ // reject rollback, so resolve the requested boundary with metadata only
+ // before allocating a child. Never rewrite indexed rollout files.
+ lastTurnId = await resolveForkTurnAnchor(
+ (method, params) => host.request(method, params),
+ opts.sourceSdkSessionId,
+ opts.forkAtTimestampMs,
+ );
+ }
+ forkRouteSignal.throwIfAborted();
+ if (!selection.isCurrent()) throw new CodexRouteSelectionChangedError();
+ const usedNativeForkAnchor = Boolean(
+ lastTurnId && !opts.stripEncryptedReasoning && supportsCodexNativeTurnFork(initResp.userAgent),
+ );
+ const params: ThreadForkParams = {
+ threadId: opts.sourceSdkSessionId,
+ ...(preparedSourcePath ? { path: preparedSourcePath } : {}),
+ ...(!usedNativeForkAnchor ? { persistExtendedHistory: true } : {}),
+ ...(usedNativeForkAnchor ? { lastTurnId } : {}),
+ // 响应体瘦身:fork 后 Cindy 自己的会话数据负责历史展示,thread.turns 全量
+ // 回传只会撑爆单行上限。老 daemon 不认识该字段则保持 legacy 行为 —— 此时
+ // 一次性 host 的隔离仍兜住故障半径。
+ ...(supportsCodexForkExcludeTurns(initResp.userAgent) ? { excludeTurns: true } : {}),
+ ...(opts.workingDir ? { cwd: opts.workingDir } : {}),
+ };
+ // Once dispatched, a lost response may still mean a child was allocated.
+ stage = 'thread-fork';
+ const resp = await host.request<ThreadForkResponse>(Method.ThreadFork, params, {
+ beforeDispatch: () => {
+ forkRouteSignal.throwIfAborted();
+ if (!selection.isCurrent()) throw new CodexRouteSelectionChangedError();
+ forkDispatched = true;
+ },
+ });
+ return { host, resp, initResp, usedNativeForkAnchor };
+ } catch (error) {
+ if (!forkDispatched && error instanceof CodexRouteSelectionChangedError && !forkRouteSignal.aborted) {
+ await retireForkHost(true);
+ releaseForkLease?.();
+ releaseForkLease = undefined;
+ forkHost = undefined;
+ if (attempt < 7) continue;
+ }
+ if (opts.stripEncryptedReasoning && error instanceof AgentNotAuthenticatedError) {
+ throw new CodexHistoryRecoveryRequiredError();
+ }
+ throw error;
}
- throw error;
- });
- return { key: forkHostKey, host };
- });
- const { host } = leased;
- releaseForkLease = leased.release;
- forkHost = host;
- stage = 'host-start';
- const initResp = await host.ensureStarted();
- // Child rollout discovery scans this.codexHome. The fork host may be
- // the first host started by this process, so hydrate it here.
- const forkCodexHome = initResp.codexHome ?? undefined;
- if (forkCodexHome && !forkAccountId && !forkStorage) this.codexHome = forkCodexHome;
- // Imported Codex threads may still live under another CODEX_HOME. Resume
- // already asks the desktop host to link/adopt their state and rollout;
- // fork must cross the same preparation boundary before thread/fork or the
- // fork app-server cannot resolve a freshly imported thread.
- // A first host may have just created the managed state DB needed for imports.
- stage = 'source-prepare';
- preparedSourcePath ??= await this.deps.prepareCodexResumeSession?.(opts.sourceSdkSessionId);
- if (opts.stripEncryptedReasoning && !historyChecked) {
- // Check before allocating a child: indexed native history must go through
- // Cindy's handoff recovery, never a file rewrite that invalidates Codex's DB.
- await assertCodexRolloutRewriteSupported(preparedSourcePath || await this.findRolloutPath(opts.sourceSdkSessionId));
- }
- if (
- !lastTurnId && (tailTurnsToDrop > 0 || opts.forkAtTimestampMs !== undefined) && !opts.stripEncryptedReasoning
- && codexUserAgentAtLeast(initResp.userAgent, [0, 153, 4])
- ) {
- // Older/failed messages have no persisted UI anchor. Paginated threads
- // reject rollback, so resolve the requested boundary with metadata only
- // before allocating a child. Never rewrite indexed rollout files.
- lastTurnId = await resolveForkTurnAnchor(
- (method, params) => host.request(method, params),
- opts.sourceSdkSessionId,
- opts.forkAtTimestampMs,
- );
- }
- const usedNativeForkAnchor = Boolean(
- lastTurnId && !opts.stripEncryptedReasoning && supportsCodexNativeTurnFork(initResp.userAgent),
- );
- const params: ThreadForkParams = {
- threadId: opts.sourceSdkSessionId,
- ...(preparedSourcePath ? { path: preparedSourcePath } : {}),
- ...(!usedNativeForkAnchor ? { persistExtendedHistory: true } : {}),
- ...(usedNativeForkAnchor ? { lastTurnId } : {}),
- // 响应体瘦身:fork 后 Cindy 自己的会话数据负责历史展示,thread.turns 全量
- // 回传只会撑爆单行上限。老 daemon 不认识该字段则保持 legacy 行为 —— 此时
- // 一次性 host 的隔离仍兜住故障半径。
- ...(supportsCodexForkExcludeTurns(initResp.userAgent) ? { excludeTurns: true } : {}),
- ...(opts.workingDir ? { cwd: opts.workingDir } : {}),
- };
- // Once dispatched, a lost response may still mean a child was allocated.
- stage = 'thread-fork';
- const resp = await host.request<ThreadForkResponse>(Method.ThreadFork, params);
+ }
+ })();
let newSdkSessionId = resp.thread.id;
if (forkCodexHome && typeof resp.thread.path === 'string') {
await this.deps.recordCodexThreadLocation?.(newSdkSessionId, forkSqliteHome ?? forkCodexHome, resp.thread.path);
@@ -14642,6 +14943,8 @@ export class CodexAgent extends BaseAgent {
* SSH-bridged 各一份)。Windows 不会随父进程死, 必须显式收割。幂等。
*/
async dispose(): Promise<void> {
+ this.routeResolutionAbort.abort(new Error('Codex route selection cancelled by dispose'));
+ this.routeResolutionAbort = new AbortController();
this.deps.logger.error('codex dispose called', {
hostCount: this.hosts.size,
inflightCount: this.hostPromises.size,
@@ -14729,8 +15032,11 @@ export class CodexAgent extends BaseAgent {
* 这些 host 都持有本机凭证,账号边界变化后不能继续复用;remote hosts 使用远端
* 用户配置,不在本次清理范围内。
*/
- async forceDisposeLocalHostForAuthChange(reason = 'CodexAgent local auth changed'): Promise<void> {
- const keys = new Set<string>([hostKey()]);
+ async forceDisposeLocalHostForAuthChange(
+ reason = 'CodexAgent local auth changed',
+ options: { preserveExternalAuth?: boolean } = {},
+ ): Promise<void> {
+ const keys = new Set<string>([hostKey(), codexLocalAuthHostIdentity(hostKey(), 'isolated')]);
for (const key of this.hosts.keys()) {
if (
key.startsWith('local-account:openai:') || isLocalControlPlaneHostKey(key) ||
@@ -14747,7 +15053,9 @@ export class CodexAgent extends BaseAgent {
isLocalCustomContextHostKey(key)
) keys.add(key);
}
- await Promise.all(Array.from(keys, (key) =>
+ await Promise.all(Array.from(keys).filter((key) =>
+ !options.preserveExternalAuth || !key.endsWith(':external-auth'),
+ ).map((key) =>
this.retireHostKey(key, reason, {
failIfActive: false,
logPrefix: 'codex local auth restart',
@@ -14788,6 +15096,7 @@ export class CodexAgent extends BaseAgent {
};
const promise = Promise.resolve().then(() => host.retire(reason, { throwOnTransportError: true }));
entry.promise = promise;
+ this.hostRetirementResults.set(host, promise);
this.retiringHosts.set(key, entry);
// 失败保留 key/Host 屏障;下次请求可重查迟到的 exit,不自动重试或另启 writer。
void promise.then(() => {
diff --git a/packages/maker-core/src/agents/codex/oauth-isolation.integration.test.ts b/packages/maker-core/src/agents/codex/oauth-isolation.integration.test.ts
new file mode 100644
index 0000000000..40b457e30f
--- /dev/null
+++ b/packages/maker-core/src/agents/codex/oauth-isolation.integration.test.ts
@@ -0,0 +1,105 @@
+import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import type { Logger } from '../../interfaces/logger.js';
+import { CodexAgent } from './index.js';
+
+// Explicit opt-in: never discover a user's installed runtime or credentials.
+const binaryPath = process.env.CINDY_TEST_CODEX_BINARY;
+const logger: Logger = {
+ trace() {}, debug() {}, info() {}, warn() {}, error() {}, fatal() {},
+ child: () => logger,
+};
+
+describe.skipIf(!binaryPath)('CodexAgent disk OAuth isolation with real app-server', () => {
+ it.each([false, true])('completes a custom Responses turn with revoked OAuth=%s', async (revoked) => {
+ const root = await mkdtemp(path.join(tmpdir(), 'cindy-codex-host-auth-'));
+ const home = path.join(root, 'codex');
+ const workingDir = path.join(root, 'work');
+ await mkdir(home);
+ await mkdir(workingDir);
+ const calls: string[] = [];
+ const server = createServer(async (req, res) => {
+ for await (const chunk of req) void chunk;
+ calls.push(`${req.method} ${req.url}`);
+ if (req.url === '/provider/responses') {
+ expect(req.headers.authorization).toBe('Bearer synthetic-invalid-api-key');
+ res.writeHead(200, { 'content-type': 'text/event-stream', connection: 'close' });
+ const events = [
+ { type: 'response.created', response: { id: 'response-fixture' } },
+ { type: 'response.output_item.done', item: { type: 'message', role: 'assistant', id: 'message-fixture', content: [{ type: 'output_text', text: 'fixture complete' }] } },
+ { type: 'response.completed', response: { id: 'response-fixture', usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } } },
+ ];
+ res.end(events.map((event) => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`).join(''));
+ } else {
+ res.writeHead(401, { 'content-type': 'application/json' });
+ res.end(JSON.stringify({ error: { code: req.url === '/oauth/token' ? 'refresh_token_invalidated' : 'unauthorized', message: 'synthetic revoked token' } }));
+ }
+ });
+ await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+ const endpoint = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+ const authPath = path.join(home, 'auth.json');
+ let authFixture: string | undefined;
+ if (revoked) {
+ const encode = (value: unknown) => Buffer.from(JSON.stringify(value)).toString('base64url');
+ authFixture = JSON.stringify({
+ auth_mode: 'chatgpt', OPENAI_API_KEY: null,
+ tokens: {
+ id_token: `${encode({ alg: 'none', typ: 'JWT' })}.${encode({ email: '[email protected]', 'https://api.openai.com/auth': { chatgpt_plan_type: 'business', chatgpt_user_id: 'fixture-user', chatgpt_account_id: 'fixture-account' } })}.c3ludGhldGlj`,
+ access_token: 'synthetic-invalid-access-token', refresh_token: 'synthetic-invalid-refresh-token', account_id: 'fixture-account',
+ }, last_refresh: new Date().toISOString(),
+ });
+ await writeFile(authPath, authFixture, { mode: 0o600 });
+ }
+ await writeFile(path.join(home, 'config.toml'), [
+ 'model="fixture-model"', 'model_provider="fixture"', 'cli_auth_credentials_store="file"',
+ `chatgpt_base_url="${endpoint}"`, 'check_for_update_on_startup=false',
+ '[analytics]', 'enabled=false',
+ '[mcp_servers.cindy_memory]', 'command="/usr/bin/false"', 'enabled=false',
+ '[model_providers.fixture]', 'name="Fixture"', `base_url="${endpoint}/provider"`,
+ 'wire_api="responses"', 'env_key="FIXTURE_API_KEY"', 'requires_openai_auth=false', 'supports_websockets=false', 'request_max_retries=0',
+ ].join('\n'));
+ const agent = new CodexAgent({
+ binaryPath: binaryPath!, logger, runtimeConfig: {},
+ resolveCodexLocalAuthPolicy: (providerId) => providerId === 'cprov-fixture' ? 'isolated' : 'legacy-shared',
+ prepareCodexExtraSpawnConfig: async () => ({ extraArgs: [], extraEnv: {}, codexProxyActive: true }),
+ auth: {
+ getState: async () => ({ authenticated: true }),
+ triggerLogin: async () => ({ authenticated: true }), logout: async () => {},
+ getAuthEnv: async () => ({
+ HOME: root, CODEX_HOME: home, TMPDIR: root, FIXTURE_API_KEY: 'synthetic-invalid-api-key',
+ OPENAI_API_KEY: '', CODEX_API_KEY: '',
+ CODEX_REFRESH_TOKEN_URL_OVERRIDE: `${endpoint}/oauth/token`,
+ HTTP_PROXY: endpoint, HTTPS_PROXY: endpoint, ALL_PROXY: endpoint, NO_PROXY: '127.0.0.1,localhost',
+ }),
+ },
+ });
+ try {
+ if (revoked) {
+ await expect(agent.startSession({ sessionId: 'official-revoked', providerId: 'openai', model: 'fixture-model', workingDir })).rejects.toThrow(/refresh|revoked|logged out/i);
+ expect(calls.some((call) => call.includes('/oauth/token'))).toBe(true);
+ }
+ const cloudCallsBeforeCustom = calls.filter((call) => call.includes('/oauth/token') || call.includes('/config/bundle'));
+ const handle = await agent.startSession({ sessionId: `fixture-${revoked}`, providerId: 'cprov-fixture', model: 'fixture-model', workingDir });
+ const events = (async () => {
+ for await (const event of handle.events()) {
+ if (event.type === 'error') throw new Error(JSON.stringify(event));
+ if (event.type === 'done') return;
+ }
+ })();
+ await handle.send({ type: 'user', content: 'return fixture complete' }, { throwOnStartFailure: true });
+ await expect.poll(() => calls.filter((call) => call === 'POST /provider/responses').length, { timeout: 10_000 }).toBe(1);
+ expect(calls.filter((call) => call.includes('/oauth/token') || call.includes('/config/bundle'))).toEqual(cloudCallsBeforeCustom);
+ if (authFixture) expect(await readFile(authPath, 'utf8')).toBe(authFixture);
+ await events;
+ await handle.close();
+ } finally {
+ await agent.dispose();
+ await new Promise<void>((resolve) => server.close(() => resolve()));
+ await rm(root, { recursive: true, force: true });
+ }
+ }, 45_000);
+});
diff --git a/packages/maker-core/src/maker.shutdown.test.ts b/packages/maker-core/src/maker.shutdown.test.ts
index 1240067509..0169372f8b 100644
--- a/packages/maker-core/src/maker.shutdown.test.ts
+++ b/packages/maker-core/src/maker.shutdown.test.ts
@@ -1,3 +1,4 @@
+import { CodexAgent } from './agents/codex/index.js';
import { describe, expect, it, vi } from 'vitest';
import { Maker } from './maker.js';
@@ -87,13 +88,93 @@ function createAgent(handle: AgentSessionHandle): BaseAgent {
} as unknown as BaseAgent;
}
-function createDeferred(): { promise: Promise<void>; resolve: () => void } {
- let resolve!: () => void;
- const promise = new Promise<void>((res) => { resolve = res; });
+function createDeferred<T = void>(): { promise: Promise<T>; resolve: (value: T | PromiseLike<T>) => void } {
+ let resolve!: (value: T | PromiseLike<T>) => void;
+ const promise = new Promise<T>((res) => { resolve = res; });
return { promise, resolve };
}
describe('Maker.shutdown', () => {
+ it.each(['exhaust', 'exhaust-route', 'cancel'] as const)('settles Maker startup after native initialization %s', async mode => {
+ const module = await import('./agents/codex/app-server/stdioTransport.js');
+ let release!: () => void;
+ const gate = new Promise<void>(resolve => { release = resolve; });
+ const methods: string[] = [];
+ let routeCurrent = true;
+ const spawn = vi.spyOn(module, 'createStdioTransport').mockImplementation(() => {
+ const closeHandlers = new Set<import('./agents/codex/app-server/transport.js').CloseHandler>();
+ let failed = false;
+ return {
+ nativeSqliteInitializationFailed: () => failed,
+ onLine: () => () => {},
+ onClose: handler => { closeHandlers.add(handler); return () => closeHandlers.delete(handler); },
+ writeLine: async line => {
+ methods.push(JSON.parse(line).method);
+ if (mode === 'exhaust-route' && methods.length === 3) routeCurrent = false;
+ failed = true;
+ for (const handler of closeHandlers) handler({ reason: 'native exited before initialize' });
+ },
+ close: async () => { if (mode === 'cancel') await gate; },
+ };
+ });
+ const agent = new CodexAgent({ logger, binaryPath: 'synthetic', runtimeConfig: {},
+ resolveCodexLocalAuthPolicy: () => ({ policy: 'legacy-shared', isCurrent: () => routeCurrent }),
+ auth: { getState: async () => ({ authenticated: true }), getAuthEnv: async () => ({}), triggerLogin: async () => ({ authenticated: true }), logout: async () => {} },
+ });
+ let guarded = false;
+ const failed = vi.fn(({ runtimeMayBeAlive }: { runtimeMayBeAlive?: boolean }) => { if (!runtimeMayBeAlive) guarded = false; });
+ const maker = new Maker({ agents: { codex: agent }, storage: createStorage(), logger,
+ lifecycleHooks: { onBeforeStart: async () => { guarded = true; }, onStartFailed: failed },
+ });
+ try {
+ const startup = maker.createSession({ id: 'native-stop', agentKind: 'codex', model: 'fixture', providerId: 'openai', workingDir: '/fixture' });
+ const rejection = expect(startup).rejects.toThrow(mode === 'cancel' ? /cancelled/ : /initialization stopped/);
+ await vi.waitFor(() => expect(spawn).toHaveBeenCalled());
+ if (mode === 'cancel') { const disposing = agent.dispose(); release(); await disposing; }
+ await rejection;
+ expect(spawn).toHaveBeenCalledTimes(mode === 'cancel' ? 1 : 3);
+ expect(methods.every(method => method === 'initialize')).toBe(true);
+ expect(failed).toHaveBeenCalledWith(expect.objectContaining({ runtimeMayBeAlive: false }));
+ expect(guarded).toBe(false);
+ expect(maker.listActiveSessions()).toEqual([]);
+ } finally { release(); await maker.shutdown(); spawn.mockRestore(); }
+ });
+
+ it.each(['cancel', 'exhaust', 'spawn-exhaust'] as const)('releases the real Codex startup guard after route %s before any host exists', async (mode) => {
+ let entered!: () => void;
+ const waiting = new Promise<void>((resolve) => { entered = resolve; });
+ let revision = 0;
+ const prepareSpawn = vi.fn(async () => { revision++; return { extraArgs: [], extraEnv: {}, codexProxyActive: true }; });
+ const resolveRoute = vi.fn(async () => {
+ entered();
+ if (mode === 'cancel') await new Promise<void>(() => {});
+ const captured = revision;
+ return { policy: 'isolated' as const, isCurrent: () => mode === 'spawn-exhaust' && captured === revision };
+ });
+ const agent = new CodexAgent({
+ logger, binaryPath: process.execPath, runtimeConfig: {},
+ auth: { getState: async () => ({ authenticated: true }), getAuthEnv: async () => ({}), triggerLogin: async () => ({ authenticated: true }), logout: async () => {} },
+ resolveCodexLocalAuthPolicy: resolveRoute,
+ ...(mode === 'spawn-exhaust' ? { prepareCodexExtraSpawnConfig: prepareSpawn } : {}),
+ });
+ let guarded = false;
+ const failed = vi.fn(({ runtimeMayBeAlive }: { runtimeMayBeAlive?: boolean }) => { if (!runtimeMayBeAlive) guarded = false; });
+ const maker = new Maker({ agents: { codex: agent }, storage: createStorage(), logger,
+ lifecycleHooks: { onBeforeStart: async () => { guarded = true; }, onStartFailed: failed },
+ });
+ const result = maker.createSession({ id: 'route-stop', agentKind: 'codex', model: 'fixture', providerId: 'cprov-fixture', workingDir: '/fixture' });
+ const rejection = expect(result).rejects.toThrow(mode === 'cancel' ? /cancelled/ : /changed repeatedly/);
+ await waiting;
+ if (mode === 'cancel') await agent.dispose();
+ await rejection;
+ expect(failed).toHaveBeenCalledWith(expect.objectContaining({ stage: 'agent-start', runtimeMayBeAlive: false }));
+ expect(guarded).toBe(false);
+ expect(maker.listActiveSessions()).toEqual([]);
+ if (mode !== 'cancel') expect(resolveRoute).toHaveBeenCalledTimes(8);
+ if (mode === 'spawn-exhaust') expect(prepareSpawn).toHaveBeenCalledTimes(8);
+ await maker.shutdown();
+ });
+
it('waits for deferred startup cleanup hooks before resolving', async () => {
const stopped = createDeferred();
const cleanupGate = createDeferred();
diff --git a/packages/maker-core/src/maker.ts b/packages/maker-core/src/maker.ts
index 9c2f25013e..d2f417f7a7 100644
--- a/packages/maker-core/src/maker.ts
+++ b/packages/maker-core/src/maker.ts
@@ -1481,6 +1481,12 @@ export class Maker {
return this.requireAgent(agentKind).forkSdkSession(opts);
}
+ async requiresCodexThreadHostTransfer(
+ opts: Parameters<BaseAgent['requiresCodexThreadHostTransfer']>[0],
+ ): Promise<boolean> {
+ return this.requireAgent('codex').requiresCodexThreadHostTransfer(opts);
+ }
+
// ── Agent 鉴权 ───────────────────────────────────────────────────────────
// 透传到 agent.deps.auth, 让 host 的 maker:auth:* IPC 不必直接拿 AuthAdapter,
// renderer 也不需要写死任何 vendor 名 (统一 maker:auth:get-state(agentKind) 入口)。
diff --git a/packages/maker-core/src/session.ts b/packages/maker-core/src/session.ts
index 82a65bb34b..aa5c1bf377 100644
--- a/packages/maker-core/src/session.ts
+++ b/packages/maker-core/src/session.ts
@@ -1597,6 +1597,11 @@ export class Session {
return this.handle.model;
}
+ /** Codex-only: 当前会话实际绑定的本地 host 身份。 */
+ get codexHostKey(): string | undefined {
+ return this.handle.codexHostKey;
+ }
+
/** Codex-only: 当前会话绑定的 app-server host 是否经 loopback proxy 出口。 */
get codexProxyActive(): boolean | undefined {
return this.handle.codexProxyActive;