mirror of
https://github.com/hanzoai/opencode-openai-codex-auth.git
synced 2026-09-24 17:01:02 +00:00
Numman AliandHanzo Dev
7dae285752
## 🎯 Overview Complete TypeScript rewrite with comprehensive testing, modular architecture, and enhanced user experience. Adds 9 pre-configured model variants matching Codex CLI presets and a beautiful OAuth success page. ## ✨ New Features ### Configuration System - **9 Model Variants**: Pre-configured reasoning levels (Low/Medium/High) for both gpt-5-codex and gpt-5, plus Minimal variants - **Full Config Example**: `config/full-opencode.json` with all variants ready to use - **Minimal Config Example**: `config/minimal-opencode.json` for basic setup - **Config Documentation**: Comprehensive guide in `config/README.md` ### OAuth Enhancement - **Animated Success Page**: Beautiful terminal-style UI with matrix rain effect, animated checkmark, and glowing effects - **Interactive Elements**: Mouse-responsive matrix rain and parallax effects - **Professional Branding**: OpenCode logo with pulse animations ### Developer Experience - **TypeScript Rewrite**: Complete migration from .mjs to .ts with strict typing - **93 Comprehensive Tests**: Full test coverage using Vitest - **Modular Architecture**: 10 focused helper functions, each < 40 lines - **Centralized Constants**: All magic values in `lib/constants.ts` - **CI/CD Pipeline**: GitHub Actions workflow for automated testing ### Documentation - **AGENTS.md**: Complete guide for AI assistants maintaining the codebase - **Enhanced README**: Updated with new configuration options and examples - **Inline JSDoc**: Comprehensive documentation for all public functions ## 🏗️ Technical Changes ### Architecture Improvements - Extracted 10 focused helper functions from monolithic fetch() - Centralized all constants and error messages - Separated concerns: auth, browser, codex, server, etc. - Type-safe discriminated unions for result types ### Build System - TypeScript compilation with declarations and source maps - Automatic HTML asset copying in build process - Test files excluded from distribution bundle - Clean dist/ output with only production code ### Testing Infrastructure - Vitest test runner with UI mode - 93 tests across 7 test files - Mock-based testing for external dependencies - Coverage reporting capability ## 📁 New Structure ``` opencode-openai-codex-auth/ ├── index.ts # Main plugin (TypeScript) ├── lib/ │ ├── auth.ts # OAuth logic │ ├── browser.ts # Platform-specific browser opening │ ├── codex.ts # Codex instructions │ ├── server.ts # OAuth callback server │ ├── fetch-helpers.ts # 10 focused helpers │ ├── constants.ts # All magic values │ ├── types.ts # TypeScript types │ ├── oauth-success.html # Animated success page │ └── ... ├── config/ │ ├── full-opencode.json # Complete config with variants │ ├── minimal-opencode.json # Basic config │ └── README.md # Config docs ├── test/ # 93 comprehensive tests ├── AGENTS.md # AI maintenance guide └── tsconfig.json # TypeScript config ``` ## 🔄 Migration Notes ### Breaking Changes - Plugin now requires TypeScript compilation (dist/ folder) - Configuration structure enhanced (backward compatible) - OAuth success page replaces plain HTML response ### Upgrade Path 1. Use new config from `config/full-opencode.json` for best experience 2. Or continue with minimal config (uses plugin defaults) 3. Rebuild plugin: `npm run build` ## 📊 Metrics - **Lines of Code**: Modular design with functions < 70 lines - **Test Coverage**: 93 tests covering all functionality - **Type Safety**: Strict TypeScript with no `any` types - **Dependencies**: Still minimal (only @openauthjs/openauth) - **Model Variants**: 9 pre-configured options for users ## 🎨 User Experience - **Codex CLI Parity**: Match official CLI reasoning presets - **Beautiful OAuth**: Professional animated success page - **Clear Documentation**: Step-by-step guides and examples - **Flexible Config**: From minimal to comprehensive setups Co-authored-by: Hanzo Dev <[email protected]>
290 lines
8.6 KiB
TypeScript
290 lines
8.6 KiB
TypeScript
import { describe, it, expect } from 'vitest';
|
|
import {
|
|
normalizeModel,
|
|
filterInput,
|
|
addToolRemapMessage,
|
|
transformRequestBody,
|
|
} from '../lib/request-transformer.js';
|
|
import { TOOL_REMAP_MESSAGE } from '../lib/codex.js';
|
|
import type { RequestBody, UserConfig, InputItem } from '../lib/types.js';
|
|
|
|
describe('Request Transformer Module', () => {
|
|
describe('normalizeModel', () => {
|
|
it('should normalize gpt-5-codex', () => {
|
|
expect(normalizeModel('gpt-5-codex')).toBe('gpt-5-codex');
|
|
});
|
|
|
|
it('should normalize gpt-5', () => {
|
|
expect(normalizeModel('gpt-5')).toBe('gpt-5');
|
|
});
|
|
|
|
it('should normalize variants containing "codex"', () => {
|
|
expect(normalizeModel('openai/gpt-5-codex')).toBe('gpt-5-codex');
|
|
expect(normalizeModel('custom-gpt-5-codex-variant')).toBe('gpt-5-codex');
|
|
});
|
|
|
|
it('should normalize variants containing "gpt-5"', () => {
|
|
expect(normalizeModel('gpt-5-mini')).toBe('gpt-5');
|
|
expect(normalizeModel('gpt-5-nano')).toBe('gpt-5');
|
|
});
|
|
|
|
it('should return gpt-5 as default for unknown models', () => {
|
|
expect(normalizeModel('unknown-model')).toBe('gpt-5');
|
|
expect(normalizeModel('gpt-4')).toBe('gpt-5');
|
|
});
|
|
|
|
it('should return gpt-5 for undefined', () => {
|
|
expect(normalizeModel(undefined)).toBe('gpt-5');
|
|
});
|
|
});
|
|
|
|
describe('filterInput', () => {
|
|
it('should keep items without IDs', () => {
|
|
const input: InputItem[] = [
|
|
{ type: 'message', role: 'user', content: 'hello' },
|
|
];
|
|
const result = filterInput(input);
|
|
expect(result).toEqual(input);
|
|
});
|
|
|
|
it('should remove items with rs_ IDs', () => {
|
|
const input: InputItem[] = [
|
|
{ id: 'rs_123', type: 'message', role: 'user', content: 'hello' },
|
|
{ id: 'msg_456', type: 'message', role: 'user', content: 'world' },
|
|
];
|
|
const result = filterInput(input);
|
|
expect(result).toHaveLength(1);
|
|
expect(result![0].id).toBe('msg_456');
|
|
});
|
|
|
|
it('should handle mixed items', () => {
|
|
const input: InputItem[] = [
|
|
{ type: 'message', role: 'user', content: '1' },
|
|
{ id: 'rs_stored', type: 'message', role: 'assistant', content: '2' },
|
|
{ id: 'msg_123', type: 'message', role: 'user', content: '3' },
|
|
];
|
|
const result = filterInput(input);
|
|
expect(result).toHaveLength(2);
|
|
expect(result![0].content).toBe('1');
|
|
expect(result![1].content).toBe('3');
|
|
});
|
|
|
|
it('should return undefined for undefined input', () => {
|
|
expect(filterInput(undefined)).toBeUndefined();
|
|
});
|
|
|
|
it('should return non-array input as-is', () => {
|
|
const notArray = { notAnArray: true };
|
|
expect(filterInput(notArray as any)).toBe(notArray);
|
|
});
|
|
});
|
|
|
|
describe('addToolRemapMessage', () => {
|
|
it('should prepend tool remap message when tools present', () => {
|
|
const input: InputItem[] = [
|
|
{ type: 'message', role: 'user', content: 'hello' },
|
|
];
|
|
const result = addToolRemapMessage(input, true);
|
|
|
|
expect(result).toHaveLength(2);
|
|
expect(result![0].role).toBe('developer');
|
|
expect(result![0].type).toBe('message');
|
|
expect((result![0].content as any)[0].text).toContain('apply_patch');
|
|
});
|
|
|
|
it('should not modify input when tools not present', () => {
|
|
const input: InputItem[] = [
|
|
{ type: 'message', role: 'user', content: 'hello' },
|
|
];
|
|
const result = addToolRemapMessage(input, false);
|
|
expect(result).toEqual(input);
|
|
});
|
|
|
|
it('should return undefined for undefined input', () => {
|
|
expect(addToolRemapMessage(undefined, true)).toBeUndefined();
|
|
});
|
|
|
|
it('should handle non-array input', () => {
|
|
const notArray = { notAnArray: true };
|
|
expect(addToolRemapMessage(notArray as any, true)).toBe(notArray);
|
|
});
|
|
});
|
|
|
|
describe('transformRequestBody', () => {
|
|
const codexInstructions = 'Test Codex Instructions';
|
|
|
|
it('should set required Codex fields', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [],
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions);
|
|
|
|
expect(result.store).toBe(false);
|
|
expect(result.stream).toBe(true);
|
|
expect(result.instructions).toBe(codexInstructions);
|
|
});
|
|
|
|
it('should normalize model name', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5-mini',
|
|
input: [],
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions);
|
|
expect(result.model).toBe('gpt-5');
|
|
});
|
|
|
|
it('should apply default reasoning config', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [],
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions);
|
|
|
|
expect(result.reasoning?.effort).toBe('medium');
|
|
expect(result.reasoning?.summary).toBe('auto');
|
|
});
|
|
|
|
it('should apply user reasoning config', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [],
|
|
};
|
|
const userConfig: UserConfig = {
|
|
global: {
|
|
reasoningEffort: 'high',
|
|
reasoningSummary: 'detailed',
|
|
},
|
|
models: {},
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions, userConfig);
|
|
|
|
expect(result.reasoning?.effort).toBe('high');
|
|
expect(result.reasoning?.summary).toBe('detailed');
|
|
});
|
|
|
|
it('should apply default text verbosity', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [],
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions);
|
|
expect(result.text?.verbosity).toBe('medium');
|
|
});
|
|
|
|
it('should apply user text verbosity', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [],
|
|
};
|
|
const userConfig: UserConfig = {
|
|
global: { textVerbosity: 'low' },
|
|
models: {},
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions, userConfig);
|
|
expect(result.text?.verbosity).toBe('low');
|
|
});
|
|
|
|
it('should set default include for encrypted reasoning', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [],
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions);
|
|
expect(result.include).toEqual(['reasoning.encrypted_content']);
|
|
});
|
|
|
|
it('should use user-configured include', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [],
|
|
};
|
|
const userConfig: UserConfig = {
|
|
global: { include: ['custom_field', 'reasoning.encrypted_content'] },
|
|
models: {},
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions, userConfig);
|
|
expect(result.include).toEqual(['custom_field', 'reasoning.encrypted_content']);
|
|
});
|
|
|
|
it('should filter input array', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [
|
|
{ id: 'rs_123', type: 'message', role: 'assistant', content: 'old' },
|
|
{ type: 'message', role: 'user', content: 'new' },
|
|
],
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions);
|
|
expect(result.input).toHaveLength(1);
|
|
expect(result.input![0].content).toBe('new');
|
|
});
|
|
|
|
it('should add tool remap message when tools present', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [{ type: 'message', role: 'user', content: 'hello' }],
|
|
tools: [{ name: 'test_tool' }],
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions);
|
|
expect(result.input![0].role).toBe('developer');
|
|
});
|
|
|
|
it('should not add tool remap message when tools absent', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [{ type: 'message', role: 'user', content: 'hello' }],
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions);
|
|
expect(result.input![0].role).toBe('user');
|
|
});
|
|
|
|
it('should remove unsupported parameters', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [],
|
|
max_output_tokens: 1000,
|
|
max_completion_tokens: 2000,
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions);
|
|
expect(result.max_output_tokens).toBeUndefined();
|
|
expect(result.max_completion_tokens).toBeUndefined();
|
|
});
|
|
|
|
it('should normalize minimal to low for gpt-5-codex', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5-codex',
|
|
input: [],
|
|
};
|
|
const userConfig: UserConfig = {
|
|
global: { reasoningEffort: 'minimal' },
|
|
models: {},
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions, userConfig);
|
|
expect(result.reasoning?.effort).toBe('low');
|
|
});
|
|
|
|
it('should preserve minimal for non-codex models', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5',
|
|
input: [],
|
|
};
|
|
const userConfig: UserConfig = {
|
|
global: { reasoningEffort: 'minimal' },
|
|
models: {},
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions, userConfig);
|
|
expect(result.reasoning?.effort).toBe('minimal');
|
|
});
|
|
|
|
it('should use minimal effort for lightweight models', () => {
|
|
const body: RequestBody = {
|
|
model: 'gpt-5-nano',
|
|
input: [],
|
|
};
|
|
const result = transformRequestBody(body, codexInstructions);
|
|
expect(result.reasoning?.effort).toBe('minimal');
|
|
});
|
|
});
|
|
});
|