@mseep/claudian 2.0.25

package/tests/unit/providers/codex/runtime/CodexSessionManager.test.ts

@@ -0,0 +1,82 @@
+import { CodexSessionManager } from '@/providers/codex/runtime/CodexSessionManager';
+
+describe('CodexSessionManager', () => {
+  let manager: CodexSessionManager;
+
+  beforeEach(() => {
+    manager = new CodexSessionManager();
+  });
+
+  describe('getThreadId and setThread', () => {
+    it('should initially return null', () => {
+      expect(manager.getThreadId()).toBeNull();
+    });
+
+    it('should set and get thread ID', () => {
+      manager.setThread('thread_abc123');
+      expect(manager.getThreadId()).toBe('thread_abc123');
+    });
+
+    it('should set session file path when provided', () => {
+      manager.setThread('thread_abc123', '/path/to/session.jsonl');
+      expect(manager.getSessionFilePath()).toBe('/path/to/session.jsonl');
+    });
+
+    it('clears the session file path when switching to a new thread without one', () => {
+      manager.setThread('thread_1', '/path/to/first.jsonl');
+      manager.setThread('thread_2');
+      expect(manager.getThreadId()).toBe('thread_2');
+      expect(manager.getSessionFilePath()).toBeNull();
+    });
+
+    it('retains the session file path when the same thread is re-applied without one', () => {
+      manager.setThread('thread_1', '/path/to/first.jsonl');
+      manager.setThread('thread_1');
+
+      expect(manager.getSessionFilePath()).toBe('/path/to/first.jsonl');
+    });
+  });
+
+  describe('getSessionFilePath', () => {
+    it('should initially return null', () => {
+      expect(manager.getSessionFilePath()).toBeNull();
+    });
+  });
+
+  describe('reset', () => {
+    it('should clear thread ID', () => {
+      manager.setThread('thread_abc123');
+      manager.reset();
+      expect(manager.getThreadId()).toBeNull();
+    });
+
+    it('should clear session file path', () => {
+      manager.setThread('thread_abc123', '/path/to/session.jsonl');
+      manager.reset();
+      expect(manager.getSessionFilePath()).toBeNull();
+    });
+
+    it('should clear invalidation state', () => {
+      manager.invalidateSession();
+      manager.reset();
+      expect(manager.consumeInvalidation()).toBe(false);
+    });
+  });
+
+  describe('invalidation', () => {
+    it('should not be invalidated initially', () => {
+      expect(manager.consumeInvalidation()).toBe(false);
+    });
+
+    it('should track invalidation', () => {
+      manager.invalidateSession();
+      expect(manager.consumeInvalidation()).toBe(true);
+    });
+
+    it('should consume invalidation (one-shot)', () => {
+      manager.invalidateSession();
+      expect(manager.consumeInvalidation()).toBe(true);
+      expect(manager.consumeInvalidation()).toBe(false);
+    });
+  });
+});

package/tests/unit/providers/codex/runtime/codexAppServerTypes.test.ts

@@ -0,0 +1,336 @@
+/**
+ * Type conformance tests for codexAppServerTypes.ts
+ *
+ * These tests verify that the local protocol types match the shapes
+ * defined by the generated app-server schema. If a type drifts from
+ * the schema, the corresponding test will fail at compile time or
+ * at runtime when constructing a conformant value.
+ */
+import type {
+  CommandApprovalRequest,
+  CommandExecutionApprovalResponse,
+  FileChangeApprovalResponse,
+  PermissionsApprovalRequest,
+  PermissionsApprovalResponse,
+  TurnSteerParams,
+  TurnSteerResult,
+  UserInputRequest,
+  UserInputResponse,
+} from '@/providers/codex/runtime/codexAppServerTypes';
+
+// ---------------------------------------------------------------------------
+// Helpers: assert a value is assignable to a type at compile time
+// ---------------------------------------------------------------------------
+function assertType<T>(_value: T): void {
+  // compile-time only
+}
+
+// ---------------------------------------------------------------------------
+// Command execution approval response
+// ---------------------------------------------------------------------------
+
+describe('CommandExecutionApprovalResponse', () => {
+  it('accepts "accept" decision', () => {
+    const response: CommandExecutionApprovalResponse = { decision: 'accept' };
+    assertType<CommandExecutionApprovalResponse>(response);
+    expect(response.decision).toBe('accept');
+  });
+
+  it('accepts "acceptForSession" decision', () => {
+    const response: CommandExecutionApprovalResponse = { decision: 'acceptForSession' };
+    assertType<CommandExecutionApprovalResponse>(response);
+    expect(response.decision).toBe('acceptForSession');
+  });
+
+  it('accepts "decline" decision', () => {
+    const response: CommandExecutionApprovalResponse = { decision: 'decline' };
+    assertType<CommandExecutionApprovalResponse>(response);
+    expect(response.decision).toBe('decline');
+  });
+
+  it('accepts "cancel" decision', () => {
+    const response: CommandExecutionApprovalResponse = { decision: 'cancel' };
+    assertType<CommandExecutionApprovalResponse>(response);
+    expect(response.decision).toBe('cancel');
+  });
+
+  it('accepts execpolicy amendment decisions', () => {
+    const response: CommandExecutionApprovalResponse = {
+      decision: {
+        acceptWithExecpolicyAmendment: {
+          execpolicy_amendment: ['npm', 'test'],
+        },
+      },
+    };
+    assertType<CommandExecutionApprovalResponse>(response);
+    expect(response.decision).toEqual({
+      acceptWithExecpolicyAmendment: {
+        execpolicy_amendment: ['npm', 'test'],
+      },
+    });
+  });
+
+  it('accepts network policy amendment decisions', () => {
+    const response: CommandExecutionApprovalResponse = {
+      decision: {
+        applyNetworkPolicyAmendment: {
+          network_policy_amendment: {
+            host: 'api.openai.com',
+            action: 'allow',
+          },
+        },
+      },
+    };
+    assertType<CommandExecutionApprovalResponse>(response);
+    expect(response.decision).toEqual({
+      applyNetworkPolicyAmendment: {
+        network_policy_amendment: {
+          host: 'api.openai.com',
+          action: 'allow',
+        },
+      },
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// File change approval response
+// ---------------------------------------------------------------------------
+
+describe('FileChangeApprovalResponse', () => {
+  it('accepts "accept" decision', () => {
+    const response: FileChangeApprovalResponse = { decision: 'accept' };
+    assertType<FileChangeApprovalResponse>(response);
+    expect(response.decision).toBe('accept');
+  });
+
+  it('accepts "acceptForSession" decision', () => {
+    const response: FileChangeApprovalResponse = { decision: 'acceptForSession' };
+    assertType<FileChangeApprovalResponse>(response);
+    expect(response.decision).toBe('acceptForSession');
+  });
+
+  it('accepts "decline" decision', () => {
+    const response: FileChangeApprovalResponse = { decision: 'decline' };
+    assertType<FileChangeApprovalResponse>(response);
+    expect(response.decision).toBe('decline');
+  });
+
+  it('accepts "cancel" decision', () => {
+    const response: FileChangeApprovalResponse = { decision: 'cancel' };
+    assertType<FileChangeApprovalResponse>(response);
+    expect(response.decision).toBe('cancel');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Permissions approval — structured response, NOT a decision enum
+// ---------------------------------------------------------------------------
+
+describe('PermissionsApprovalResponse', () => {
+  it('accepts a grant with turn scope', () => {
+    const response: PermissionsApprovalResponse = {
+      permissions: {
+        fileSystem: { read: ['/tmp'], write: null },
+        network: null,
+      },
+      scope: 'turn',
+    };
+    assertType<PermissionsApprovalResponse>(response);
+    expect(response.scope).toBe('turn');
+    expect(response.permissions.fileSystem?.read).toEqual(['/tmp']);
+  });
+
+  it('accepts a grant with session scope', () => {
+    const response: PermissionsApprovalResponse = {
+      permissions: {
+        fileSystem: null,
+        network: { enabled: true },
+      },
+      scope: 'session',
+    };
+    assertType<PermissionsApprovalResponse>(response);
+    expect(response.scope).toBe('session');
+  });
+
+  it('defaults scope to turn when omitted', () => {
+    const response: PermissionsApprovalResponse = {
+      permissions: {},
+    };
+    assertType<PermissionsApprovalResponse>(response);
+    expect(response.scope).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Permissions approval request — includes permissions profile
+// ---------------------------------------------------------------------------
+
+describe('PermissionsApprovalRequest', () => {
+  it('includes permissions profile from server', () => {
+    const request: PermissionsApprovalRequest = {
+      threadId: 't1',
+      turnId: 'turn1',
+      itemId: 'perm1',
+      permissions: {
+        fileSystem: { read: ['/usr/local'], write: ['/tmp'] },
+        network: { enabled: true },
+      },
+    };
+    assertType<PermissionsApprovalRequest>(request);
+    expect(request.permissions.fileSystem?.write).toEqual(['/tmp']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Command approval request — includes optional fields from schema
+// ---------------------------------------------------------------------------
+
+describe('CommandApprovalRequest', () => {
+  it('includes optional reason and commandActions', () => {
+    const request: CommandApprovalRequest = {
+      threadId: 't1',
+      turnId: 'turn1',
+      itemId: 'cmd1',
+      command: 'echo test',
+      cwd: '/workspace',
+      reason: 'needs network',
+      commandActions: [{ type: 'unknown', command: 'echo test' }],
+    };
+    assertType<CommandApprovalRequest>(request);
+    expect(request.reason).toBe('needs network');
+    expect(request.commandActions).toHaveLength(1);
+  });
+
+  it('includes network approval and amendment metadata from the schema', () => {
+    const request: CommandApprovalRequest = {
+      threadId: 't1',
+      turnId: 'turn1',
+      itemId: 'cmd1',
+      command: 'curl https://api.openai.com',
+      cwd: '/workspace',
+      networkApprovalContext: { host: 'api.openai.com', protocol: 'https' },
+      additionalPermissions: {
+        network: { enabled: true },
+        fileSystem: { read: ['/tmp'], write: ['/workspace'] },
+        macos: null,
+      },
+      proposedExecpolicyAmendment: ['curl', 'https://api.openai.com/*'],
+      proposedNetworkPolicyAmendments: [{ host: 'api.openai.com', action: 'allow' }],
+      availableDecisions: [
+        'accept',
+        {
+          acceptWithExecpolicyAmendment: {
+            execpolicy_amendment: ['curl', 'https://api.openai.com/*'],
+          },
+        },
+        {
+          applyNetworkPolicyAmendment: {
+            network_policy_amendment: { host: 'api.openai.com', action: 'allow' },
+          },
+        },
+      ],
+    };
+    assertType<CommandApprovalRequest>(request);
+    expect(request.networkApprovalContext?.host).toBe('api.openai.com');
+    expect(request.availableDecisions).toHaveLength(3);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// User input request — richer question metadata
+// ---------------------------------------------------------------------------
+
+describe('UserInputRequest', () => {
+  it('includes header, options, isOther, and isSecret on questions', () => {
+    const request: UserInputRequest = {
+      threadId: 't1',
+      turnId: 'turn1',
+      itemId: 'ui1',
+      questions: [
+        {
+          id: 'q1',
+          header: 'Confirm action',
+          question: 'Do you want to proceed?',
+          options: [
+            { label: 'Yes', description: 'Continue' },
+            { label: 'No', description: 'Stop' },
+          ],
+          isOther: false,
+          isSecret: false,
+        },
+      ],
+    };
+    assertType<UserInputRequest>(request);
+    expect(request.questions[0].header).toBe('Confirm action');
+    expect(request.questions[0].options).toHaveLength(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// User input response — answers keyed by question id
+// ---------------------------------------------------------------------------
+
+describe('UserInputResponse', () => {
+  it('keys answers by question id', () => {
+    const response: UserInputResponse = {
+      answers: {
+        q1: { answers: ['yes'] },
+        q2: { answers: ['option-a', 'option-b'] },
+      },
+    };
+    assertType<UserInputResponse>(response);
+    expect(Object.keys(response.answers)).toEqual(['q1', 'q2']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// turn/steer
+// ---------------------------------------------------------------------------
+
+describe('TurnSteer', () => {
+  it('accepts expectedTurnId and returns the active turn id', () => {
+    const params: TurnSteerParams = {
+      threadId: 'thr_123',
+      expectedTurnId: 'turn_456',
+      input: [{ type: 'text', text: 'Focus on failing tests first.' }],
+    };
+    const result: TurnSteerResult = { turnId: 'turn_456' };
+
+    assertType<TurnSteerParams>(params);
+    assertType<TurnSteerResult>(result);
+    expect(params.expectedTurnId).toBe('turn_456');
+    expect(result.turnId).toBe('turn_456');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Schema drift guards — ensure deprecated values are not reintroduced
+// ---------------------------------------------------------------------------
+
+describe('schema drift guards', () => {
+  it('CommandExecutionApprovalDecision does not include "deny" or "alwaysAccept"', () => {
+    const validValues: CommandExecutionApprovalResponse['decision'][] = [
+      'accept', 'acceptForSession', 'decline', 'cancel',
+    ];
+    expect(validValues).not.toContain('deny');
+    expect(validValues).not.toContain('alwaysAccept');
+  });
+
+  it('FileChangeApprovalDecision does not include "deny" or "alwaysAccept"', () => {
+    const validValues: FileChangeApprovalResponse['decision'][] = [
+      'accept', 'acceptForSession', 'decline', 'cancel',
+    ];
+    expect(validValues).not.toContain('deny');
+    expect(validValues).not.toContain('alwaysAccept');
+  });
+
+  it('PermissionsApprovalResponse has permissions and scope, not decision', () => {
+    const response: PermissionsApprovalResponse = {
+      permissions: {},
+      scope: 'turn',
+    };
+    expect(response).toHaveProperty('permissions');
+    expect(response).not.toHaveProperty('decision');
+  });
+});

package/tests/unit/providers/codex/settings.test.ts

@@ -0,0 +1,189 @@
+import {
+  applyCodexModelDefaults,
+  DEFAULT_CODEX_PROVIDER_SETTINGS,
+  getCodexProviderSettings,
+  getEffectiveCodexReasoningSummary,
+  updateCodexProviderSettings,
+} from '@/providers/codex/settings';
+import { CODEX_SPARK_MODEL } from '@/providers/codex/types/models';
+
+const mockGetHostnameKey = jest.fn(() => 'host-a');
+const mockGetLegacyHostnameKey = jest.fn(() => 'legacy-host');
+
+jest.mock('@/utils/env', () => ({
+  ...jest.requireActual('@/utils/env'),
+  getHostnameKey: () => mockGetHostnameKey(),
+  getLegacyHostnameKey: () => mockGetLegacyHostnameKey(),
+}));
+
+describe('codex settings', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockGetHostnameKey.mockReturnValue('host-a');
+    mockGetLegacyHostnameKey.mockReturnValue('legacy-host');
+  });
+
+  it('defaults installationMethod to native-windows and leaves wslDistroOverride empty', () => {
+    const settings = getCodexProviderSettings({});
+
+    expect(settings.customModels).toBe('');
+    expect(settings.installationMethod).toBe('native-windows');
+    expect(settings.wslDistroOverride).toBe('');
+    expect(settings.installationMethod).toBe(DEFAULT_CODEX_PROVIDER_SETTINGS.installationMethod);
+    expect(settings.wslDistroOverride).toBe(DEFAULT_CODEX_PROVIDER_SETTINGS.wslDistroOverride);
+  });
+
+  it('normalizes invalid installationMethod and wslDistroOverride values', () => {
+    const settings = getCodexProviderSettings({
+      providerConfigs: {
+        codex: {
+          installationMethod: 'auto',
+          wslDistroOverride: 123,
+        },
+      },
+    });
+
+    expect(settings.installationMethod).toBe('native-windows');
+    expect(settings.wslDistroOverride).toBe('');
+  });
+
+  it('does not inherit another host installation method once host-scoped values exist', () => {
+    const settings = getCodexProviderSettings({
+      providerConfigs: {
+        codex: {
+          installationMethodsByHost: {
+            'host-b': 'wsl',
+          },
+          wslDistroOverridesByHost: {
+            'host-b': 'Ubuntu',
+          },
+          installationMethod: 'wsl',
+          wslDistroOverride: 'Ubuntu',
+        },
+      },
+    });
+
+    expect(settings.installationMethod).toBe('native-windows');
+    expect(settings.wslDistroOverride).toBe('');
+  });
+
+  it('migrates current legacy hostname-scoped settings to the opaque device key', () => {
+    mockGetHostnameKey.mockReturnValue('device:current');
+    mockGetLegacyHostnameKey.mockReturnValue('host-a');
+
+    const settings = getCodexProviderSettings({
+      providerConfigs: {
+        codex: {
+          cliPathsByHost: {
+            'host-a': '/host-a/codex',
+            'host-b': '/host-b/codex',
+          },
+          installationMethodsByHost: {
+            'host-a': 'wsl',
+            'host-b': 'native-windows',
+          },
+          wslDistroOverridesByHost: {
+            'host-a': 'Ubuntu',
+            'host-b': 'Debian',
+          },
+        },
+      },
+    });
+
+    expect(settings.cliPathsByHost).toEqual({
+      'device:current': '/host-a/codex',
+      'host-b': '/host-b/codex',
+    });
+    expect(settings.installationMethod).toBe('wsl');
+    expect(settings.installationMethodsByHost).toEqual({
+      'device:current': 'wsl',
+      'host-b': 'native-windows',
+    });
+    expect(settings.wslDistroOverride).toBe('Ubuntu');
+    expect(settings.wslDistroOverridesByHost).toEqual({
+      'device:current': 'Ubuntu',
+      'host-b': 'Debian',
+    });
+  });
+
+  it('round-trips installationMethod and trims wslDistroOverride on update for the current host', () => {
+    const settingsBag: Record<string, unknown> = {
+      providerConfigs: {
+        codex: {},
+      },
+    };
+
+    const next = updateCodexProviderSettings(settingsBag, {
+      installationMethod: 'wsl',
+      wslDistroOverride: '  Ubuntu-24.04  ',
+    });
+
+    expect(next.installationMethod).toBe('wsl');
+    expect(next.wslDistroOverride).toBe('Ubuntu-24.04');
+    expect(getCodexProviderSettings(settingsBag)).toMatchObject({
+      installationMethod: 'wsl',
+      wslDistroOverride: 'Ubuntu-24.04',
+      installationMethodsByHost: {
+        'host-a': 'wsl',
+      },
+      wslDistroOverridesByHost: {
+        'host-a': 'Ubuntu-24.04',
+      },
+    });
+  });
+
+  it('preserves another host installation settings when updating the current host', () => {
+    const settingsBag: Record<string, unknown> = {
+      providerConfigs: {
+        codex: {
+          installationMethodsByHost: {
+            'host-b': 'wsl',
+          },
+          wslDistroOverridesByHost: {
+            'host-b': 'Debian',
+          },
+        },
+      },
+    };
+
+    const next = updateCodexProviderSettings(settingsBag, {
+      installationMethod: 'native-windows',
+      wslDistroOverride: '  ',
+    });
+
+    expect(next.installationMethodsByHost).toEqual({
+      'host-b': 'wsl',
+      'host-a': 'native-windows',
+    });
+    expect(next.wslDistroOverridesByHost).toEqual({
+      'host-b': 'Debian',
+    });
+  });
+
+  it('forces reasoning summary off for GPT-5.3 Codex Spark', () => {
+    const settingsBag: Record<string, unknown> = {
+      providerConfigs: {
+        codex: {
+          reasoningSummary: 'detailed',
+        },
+      },
+    };
+
+    expect(getEffectiveCodexReasoningSummary(settingsBag, CODEX_SPARK_MODEL)).toBe('none');
+    expect(getEffectiveCodexReasoningSummary(settingsBag, 'gpt-5.5')).toBe('detailed');
+  });
+
+  it('sets reasoning summary off when applying GPT-5.3 Codex Spark model defaults', () => {
+    const settingsBag: Record<string, unknown> = {
+      providerConfigs: {
+        codex: {
+          reasoningSummary: 'detailed',
+        },
+      },
+    };
+
+    applyCodexModelDefaults(CODEX_SPARK_MODEL, settingsBag);
+
+    expect(getCodexProviderSettings(settingsBag).reasoningSummary).toBe('none');
+  });
+});