codexmate 0.0.7 → 0.0.9

package/tests/e2e/test-claude.js

@@ -0,0 +1,21 @@
+const { assert } = require('./helpers');
+
+module.exports = async function testClaude(ctx) {
+    const { api, mockProviderUrl, claudeModel } = ctx;
+
+    const claudeSettingsInfo = await api('get-claude-settings');
+    assert(claudeSettingsInfo.apiKey === 'sk-claude', 'get-claude-settings apiKey mismatch');
+    assert(claudeSettingsInfo.baseUrl === mockProviderUrl, 'get-claude-settings baseUrl mismatch');
+    assert(claudeSettingsInfo.model === claudeModel, 'get-claude-settings model mismatch');
+
+    const claudeShareMissing = await api('export-claude-share', { config: { apiKey: 'only-key' } });
+    assert(claudeShareMissing.error, 'export-claude-share should fail when baseUrl missing');
+
+    const claudeShare = await api('export-claude-share', {
+        config: { baseUrl: mockProviderUrl, apiKey: 'sk-claude', model: claudeModel }
+    });
+    assert(claudeShare.payload, 'export-claude-share missing payload');
+    assert(claudeShare.payload.baseUrl === mockProviderUrl, 'export-claude-share baseUrl mismatch');
+    assert(claudeShare.payload.apiKey === 'sk-claude', 'export-claude-share apiKey mismatch');
+    assert(claudeShare.payload.model === claudeModel, 'export-claude-share model mismatch');
+};

package/tests/e2e/test-config.js

@@ -0,0 +1,124 @@
+const { assert } = require('./helpers');
+
+module.exports = async function testConfig(ctx) {
+    const {
+        api,
+        mockProviderUrl,
+        noModelsUrl,
+        htmlModelsUrl,
+        authFailUrl
+    } = ctx;
+
+    const apiStatus = await api('status');
+    assert(apiStatus.provider === 'e2e', 'api status provider mismatch');
+
+    const apiList = await api('list');
+    assert(Array.isArray(apiList.providers), 'api list missing providers');
+    assert(apiList.providers.some(p => p.name === 'e2e'), 'api list missing provider');
+
+    const templateOverride = await api('get-config-template', {
+        provider: 'shadow',
+        model: 'shadow-model',
+        serviceTier: 'fast'
+    });
+    assert(typeof templateOverride.template === 'string', 'get-config-template missing template');
+    assert(/^\s*service_tier\s*=\s*"fast"\s*$/m.test(templateOverride.template), 'get-config-template missing service_tier');
+    assert(templateOverride.template.includes('model_provider = "shadow"'), 'get-config-template missing provider override');
+    assert(templateOverride.template.includes('model = "shadow-model"'), 'get-config-template missing model override');
+
+    const templateStandard = await api('get-config-template', {
+        provider: 'shadow',
+        model: 'shadow-model',
+        serviceTier: 'standard'
+    });
+    assert(typeof templateStandard.template === 'string', 'get-config-template(standard) missing template');
+    assert(!/\s*service_tier\s*=/.test(templateStandard.template), 'get-config-template(standard) should not include service_tier');
+
+    const exportResult = await api('export-config', { includeKeys: true });
+    assert(exportResult.data, 'export-config missing data');
+    assert(exportResult.data.providers && exportResult.data.providers.e2e, 'export-config missing provider');
+    assert(exportResult.data.providers.e2e.apiKey === 'sk-test', 'export-config apiKey mismatch');
+
+    const exportNoKeys = await api('export-config', { includeKeys: false });
+    assert(exportNoKeys.data, 'export-config(no keys) missing data');
+    assert(exportNoKeys.data.providers && exportNoKeys.data.providers.e2e, 'export-config(no keys) missing provider');
+    assert(exportNoKeys.data.providers.e2e.apiKey === null, 'export-config(no keys) apiKey should be null');
+
+    const importInvalid = await api('import-config', { payload: null });
+    assert(importInvalid.error && importInvalid.error.includes('Invalid import payload'), 'import-config should reject invalid payload');
+
+    const modelsMissing = await api('models', { provider: 'missing' });
+    assert(modelsMissing.error, 'models should fail for missing provider');
+
+    const modelsByUrlInvalid = await api('models-by-url', { baseUrl: 'not-a-url' });
+    assert(modelsByUrlInvalid.error, 'models-by-url should fail for invalid url');
+
+    const applyEmpty = await api('apply-config-template', { template: '' });
+    assert(applyEmpty.error, 'apply-config-template should reject empty template');
+
+    const applyNoProvider = await api('apply-config-template', {
+        template: 'model = "x"\n[model_providers.x]\nbase_url = "http://example.com"\n'
+    });
+    assert(applyNoProvider.error, 'apply-config-template should require model_provider');
+
+    const applyNoModel = await api('apply-config-template', {
+        template: 'model_provider = "x"\n[model_providers.x]\nbase_url = "http://example.com"\n'
+    });
+    assert(applyNoModel.error, 'apply-config-template should require model');
+
+    const applyNoProviders = await api('apply-config-template', {
+        template: 'model_provider = "x"\nmodel = "y"\n'
+    });
+    assert(applyNoProviders.error, 'apply-config-template should require model_providers');
+
+    const importPayload = JSON.parse(JSON.stringify(exportResult.data));
+    importPayload.providers = {
+        ...importPayload.providers,
+        e2e2: { baseUrl: mockProviderUrl, apiKey: 'sk-e2e2' },
+        e2e3: { baseUrl: noModelsUrl, apiKey: 'sk-e2e3' },
+        e2e4: { baseUrl: htmlModelsUrl, apiKey: 'sk-e2e4' }
+    };
+    importPayload.models = Array.from(new Set([...(importPayload.models || []), 'e2e2-model']));
+    importPayload.currentProvider = 'e2e2';
+    importPayload.currentModel = 'e2e2-model';
+    importPayload.currentModels = { ...(importPayload.currentModels || {}), e2e2: 'e2e2-model' };
+
+    const importResult = await api('import-config', {
+        payload: importPayload,
+        options: { overwriteProviders: true, applyCurrent: true, applyCurrentModels: true }
+    });
+    assert(importResult.success === true, 'import-config failed');
+
+    const exportProviderMissing = await api('export-provider', { name: 'ghost' });
+    assert(exportProviderMissing.error, 'export-provider should fail for missing provider');
+
+    const exportProvider = await api('export-provider', { name: 'e2e2' });
+    assert(exportProvider.payload, 'export-provider missing payload');
+    assert(exportProvider.payload.baseUrl === mockProviderUrl, 'export-provider baseUrl mismatch');
+    assert(exportProvider.payload.apiKey === 'sk-e2e2', 'export-provider apiKey mismatch');
+
+    const apiStatusAfter = await api('status');
+    assert(apiStatusAfter.provider === 'e2e2', 'api status provider after import mismatch');
+    assert(apiStatusAfter.model === 'e2e2-model', 'api status model after import mismatch');
+
+    const apiModels = await api('models', { provider: 'e2e2' });
+    assert(Array.isArray(apiModels.models) && apiModels.models.includes('e2e2-model-2'), 'api models missing remote entry');
+
+    const apiModelsUnlimited = await api('models', { provider: 'e2e3' });
+    assert(apiModelsUnlimited.unlimited === true, 'api models unlimited missing');
+
+    const apiModelsHtml = await api('models', { provider: 'e2e4' });
+    assert(apiModelsHtml.unlimited === true, 'api models html unlimited missing');
+
+    const apiModelsByUrl = await api('models-by-url', { baseUrl: mockProviderUrl, apiKey: 'sk-e2e2' });
+    assert(Array.isArray(apiModelsByUrl.models) && apiModelsByUrl.models.includes('e2e2-model'), 'api models-by-url missing remote entry');
+
+    const apiModelsByUrlUnlimited = await api('models-by-url', { baseUrl: noModelsUrl });
+    assert(apiModelsByUrlUnlimited.unlimited === true, 'api models-by-url unlimited missing');
+
+    const apiPaths = await api('list-session-paths', { source: 'codex', limit: 10, forceRefresh: true });
+    assert(Array.isArray(apiPaths.paths), 'api session paths missing');
+    assert(apiPaths.paths.includes('/tmp/e2e'), 'api session paths missing cwd');
+
+    ctx.importPayload = importPayload;
+};

package/tests/e2e/test-health-speed.js

@@ -0,0 +1,79 @@
+const path = require('path');
+const {
+    assert,
+    normalizeWireApi,
+    buildModelProbeSpec,
+    fileMode,
+    writeJsonAtomic
+} = require('./helpers');
+
+module.exports = async function testHealthAndSpeed(ctx) {
+    const { api, mockProviderUrl, authFailUrl, tmpHome } = ctx;
+
+    const speedResult = await api('speed-test', { name: 'e2e2' });
+    assert(speedResult.ok === true, 'speed-test failed');
+
+    const configPath = path.join(tmpHome, '.codex', 'config.toml');
+    const originalConfig = require('fs').readFileSync(configPath, 'utf-8');
+    try {
+        const invalidConfig = [
+            'model_provider = "bad"',
+            'model = "missing"',
+            '',
+            '[model_providers.bad]',
+            'base_url = "not-a-url"',
+            'preferred_auth_method = "sk-bad"',
+            ''
+        ].join('\n');
+        require('fs').writeFileSync(configPath, invalidConfig, 'utf-8');
+
+        const healthInvalid = await api('config-health-check', { remote: false });
+        assert(healthInvalid.ok === false, 'health-check should fail for invalid base_url');
+        assert(
+            Array.isArray(healthInvalid.issues) &&
+            healthInvalid.issues.some(issue => issue.code === 'base-url-invalid'),
+            'health-check should report base-url-invalid'
+        );
+
+        const healthRemote = await api('config-health-check', { remote: true });
+        assert(healthRemote.ok === false, 'health-check(remote) should fail');
+        assert(
+            Array.isArray(healthRemote.issues) &&
+            healthRemote.issues.some(issue => issue.code === 'remote-skip-base-url'),
+            'health-check(remote) should report remote-skip-base-url'
+        );
+    } finally {
+        require('fs').writeFileSync(configPath, originalConfig, 'utf-8');
+    }
+
+    const speedInvalid = await api('speed-test', { url: 'not-a-url' });
+    assert(speedInvalid.ok === false || speedInvalid.error, 'speed-test invalid url should fail');
+
+    const speedAuthFail = await api('speed-test', { url: authFailUrl });
+    assert(
+        speedAuthFail.status === 401 || (speedAuthFail.error && /401/.test(speedAuthFail.error)),
+        'speed-test auth fail should expose 401'
+    );
+
+    const speedUnreachable = await api('speed-test', { url: 'http://127.0.0.1:1' });
+    assert(speedUnreachable.ok === false || speedUnreachable.error, 'speed-test unreachable should fail');
+
+    assert(normalizeWireApi('chat/completions') === 'chat_completions', 'normalizeWireApi should replace "/" with "_"');
+    const probeSpec = buildModelProbeSpec({ wire_api: 'chat/completions' }, 'e2e-chat', mockProviderUrl);
+    assert(probeSpec && probeSpec.url.endsWith('/chat/completions'), 'buildModelProbeSpec should use chat/completions endpoint for slash wire_api');
+
+    const permDir = require('fs').mkdtempSync(path.join(tmpHome, 'perm-'));
+    const existingPath = path.join(permDir, 'secret.json');
+    require('fs').writeFileSync(existingPath, JSON.stringify({ a: 1 }), { mode: 0o640 });
+    const origMode = fileMode(existingPath);
+    writeJsonAtomic(existingPath, { a: 2 });
+    assert(fileMode(existingPath) === origMode, 'writeJsonAtomic should preserve mode of existing file');
+
+    const newPath = path.join(permDir, 'new.json');
+    writeJsonAtomic(newPath, { b: 1 });
+    const expectedNewMode = process.platform === 'win32' ? 0o666 : 0o600;
+    assert(
+        fileMode(newPath) === expectedNewMode,
+        `writeJsonAtomic should default to ${expectedNewMode.toString(8)} for new file (got ${fileMode(newPath).toString(8)})`
+    );
+};

package/tests/e2e/test-openclaw.js

@@ -0,0 +1,47 @@
+const { assert } = require('./helpers');
+
+module.exports = async function testOpenclaw(ctx) {
+    const { api } = ctx;
+
+    const openclawReadEmpty = await api('get-openclaw-config');
+    assert(openclawReadEmpty.exists === false, 'openclaw config should not exist initially');
+
+    const openclawInvalid = await api('apply-openclaw-config', { content: '', lineEnding: '\n' });
+    assert(openclawInvalid.success === false, 'apply-openclaw-config should reject empty content');
+
+    const openclawContent = [
+        '{',
+        '  "agent": { "model": "gpt-4.1" },',
+        '  "agents": { "defaults": { "workspace": "~/.openclaw/workspace" } }',
+        '}'
+    ].join('\n');
+    const openclawApply = await api('apply-openclaw-config', { content: openclawContent, lineEnding: '\n' });
+    assert(openclawApply.success === true, `apply-openclaw-config failed${openclawApply && openclawApply.error ? `: ${openclawApply.error}` : ''}`);
+    const openclawReadAfter = await api('get-openclaw-config');
+    assert(openclawReadAfter.exists === true, 'openclaw config should exist after apply');
+
+    const openclawAgentsBefore = await api('get-openclaw-agents-file');
+    assert(openclawAgentsBefore.path, 'get-openclaw-agents-file missing path');
+    const openclawAgentsApply = await api('apply-openclaw-agents-file', { content: 'openclaw-agents', lineEnding: '\n' });
+    assert(openclawAgentsApply.success === true, 'apply-openclaw-agents-file failed');
+    const openclawAgentsAfter = await api('get-openclaw-agents-file');
+    assert(openclawAgentsAfter.exists === true, 'openclaw agents should exist after apply');
+    assert(openclawAgentsAfter.content.includes('openclaw-agents'), 'openclaw agents content mismatch');
+
+    const openclawWorkspaceInvalid = await api('apply-openclaw-workspace-file', {
+        fileName: 'bad.txt',
+        content: 'x',
+        lineEnding: '\n'
+    });
+    assert(openclawWorkspaceInvalid.error, 'apply-openclaw-workspace-file should reject invalid name');
+
+    const openclawWorkspaceApply = await api('apply-openclaw-workspace-file', {
+        fileName: 'SOUL.md',
+        content: 'workspace-content',
+        lineEnding: '\n'
+    });
+    assert(openclawWorkspaceApply.success === true, 'apply-openclaw-workspace-file failed');
+    const openclawWorkspaceRead = await api('get-openclaw-workspace-file', { fileName: 'SOUL.md' });
+    assert(openclawWorkspaceRead.exists === true, 'get-openclaw-workspace-file missing after apply');
+    assert(openclawWorkspaceRead.content.includes('workspace-content'), 'openclaw workspace content mismatch');
+};

package/tests/e2e/test-session-search.js

@@ -0,0 +1,114 @@
+const http = require('http');
+const { assert } = require('./helpers');
+
+async function fetchHtml(port) {
+    return new Promise((resolve, reject) => {
+        const req = http.get({
+            hostname: '127.0.0.1',
+            port,
+            path: '/',
+            timeout: 2000
+        }, (res) => {
+            let body = '';
+            res.setEncoding('utf-8');
+            res.on('data', chunk => body += chunk);
+            res.on('end', () => resolve(body));
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy(new Error('timeout'));
+        });
+    });
+}
+
+module.exports = async function testSessionSearch(ctx) {
+    const { api, sessionId, claudeSessionId, daudeSessionId } = ctx;
+
+    const claudeSearch = await api('list-sessions', { source: 'claude', query: 'claudecode', limit: 20, forceRefresh: true });
+    assert(Array.isArray(claudeSearch.sessions), 'claudecode query missing sessions');
+    const claudeHit = claudeSearch.sessions.find(item => item.sessionId === claudeSessionId);
+    assert(claudeHit, 'claudecode query missing Claude session');
+    assert(claudeHit.provider === 'claude', 'Claude session provider missing');
+    assert(claudeHit.capabilities && claudeHit.capabilities.code === true, 'Claude session code capability missing');
+    assert(Array.isArray(claudeHit.keywords) && claudeHit.keywords.includes('claude_code'), 'Claude session keyword missing');
+
+    const variantSearch = await api('list-sessions', { source: 'claude', query: 'claude-code', limit: 20, forceRefresh: true });
+    assert(variantSearch.sessions.some(item => item.sessionId === claudeSessionId), 'claude-code query missing Claude session');
+
+    const combined = await api('list-sessions', { source: 'claude', query: 'claude code hello', limit: 20, forceRefresh: true });
+    const combinedIds = combined.sessions.map(item => item.sessionId);
+    assert(combinedIds.includes(claudeSessionId), 'combined query missing Claude session');
+
+    const baseline = await api('list-sessions', { source: 'codex', query: 'hello', limit: 20, forceRefresh: true });
+    assert(baseline.sessions.some(item => item.sessionId === sessionId), 'baseline query missing codex session');
+
+    const daudeSearch = await api('list-sessions', {
+        source: 'codex',
+        query: 'daude code',
+        limit: 20,
+        forceRefresh: true
+    });
+    assert(daudeSearch.sessions.some(item => item.sessionId === daudeSessionId), 'daude code query missing session');
+
+    const daudeHyphen = await api('list-sessions', {
+        source: 'codex',
+        query: 'daude-code',
+        limit: 20,
+        forceRefresh: true
+    });
+    assert(daudeHyphen.sessions.some(item => item.sessionId === daudeSessionId), 'daude-code query missing session');
+
+    const daudeConcat = await api('list-sessions', {
+        source: 'codex',
+        query: 'daudecode',
+        limit: 20,
+        forceRefresh: true
+    });
+    assert(daudeConcat.sessions.some(item => item.sessionId === daudeSessionId), 'daudecode query missing session');
+
+    const highlighted = await api('list-sessions', {
+        source: 'claude',
+        query: 'claude code hello',
+        queryScope: 'all',
+        contentScanBytes: 8 * 1024,
+        limit: 5,
+        forceRefresh: true
+    });
+    const highlightedHit = highlighted.sessions.find(item => item.sessionId === claudeSessionId);
+    assert(highlightedHit, 'highlight query missing Claude session');
+    assert(highlightedHit.match && highlightedHit.match.hit === true, 'highlight match missing for Claude session');
+    assert(Array.isArray(highlightedHit.match.snippets) && highlightedHit.match.snippets.some(
+        snippet => typeof snippet === 'string' && snippet.toLowerCase().includes('hello from claude code session')
+    ), 'highlight snippets missing Claude code text');
+
+    const numeric = await api('list-sessions', {
+        source: 'codex',
+        query: '222',
+        queryScope: 'all',
+        contentScanBytes: 8 * 1024,
+        limit: 10,
+        forceRefresh: true
+    });
+    const numericHit = numeric.sessions.find(item => item.sessionId === daudeSessionId);
+    assert(numericHit, '222 query missing daude session');
+    assert(numericHit.match && numericHit.match.hit === true, '222 match missing daude session hit');
+    assert(Array.isArray(numericHit.match.snippets) && numericHit.match.snippets.some(
+        snippet => typeof snippet === 'string' && snippet.includes('222')
+    ), '222 snippets missing numeric token');
+
+    const paged = await api('list-sessions', {
+        source: 'claude',
+        query: 'claude code hello',
+        queryScope: 'all',
+        limit: 1,
+        forceRefresh: true
+    });
+    assert(Array.isArray(paged.sessions) && paged.sessions.length === 1, 'paged search should return first page only');
+    assert(paged.sessions[0].sessionId === claudeSessionId, 'paged search first item should be Claude session');
+
+    const html = await fetchHtml(ctx.port);
+    assert(html && html.includes('.session-item-snippet'), 'session snippet style missing');
+    const lowerHtml = (html || '').toLowerCase();
+    assert(lowerHtml.includes('white-space: nowrap'), 'snippet nowrap missing');
+    assert(lowerHtml.includes('text-overflow: ellipsis'), 'snippet ellipsis missing');
+};

package/tests/e2e/test-sessions.js

@@ -0,0 +1,69 @@
+const path = require('path');
+const { assert } = require('./helpers');
+
+module.exports = async function testSessions(ctx) {
+    const { api, sessionId, tmpHome, claudeSessionId } = ctx;
+
+    const apiSessions = await api('list-sessions', { source: 'codex', limit: 50, forceRefresh: true });
+    assert(Array.isArray(apiSessions.sessions), 'api sessions missing');
+    assert(apiSessions.sessions.some(item => item.sessionId === sessionId), 'api sessions missing codex entry');
+
+    const apiSessionsClaude = await api('list-sessions', { source: 'claude', limit: 50, forceRefresh: true });
+    assert(Array.isArray(apiSessionsClaude.sessions), 'api sessions(claude) missing');
+    assert(apiSessionsClaude.sessions.some(item => item.sessionId === claudeSessionId), 'api sessions(claude) missing claude entry');
+
+    const claudeCodeQuery = await api('list-sessions', { source: 'claude', query: 'claude code', limit: 50, forceRefresh: true });
+    assert(Array.isArray(claudeCodeQuery.sessions), 'claude code query missing sessions');
+    const claudeCodeHit = claudeCodeQuery.sessions.find(item => item.sessionId === claudeSessionId);
+    assert(claudeCodeHit, 'claude code query missing Claude session');
+    assert(claudeCodeHit.provider === 'claude', 'claude code query provider mismatch');
+    assert(claudeCodeHit.capabilities && claudeCodeHit.capabilities.code === true, 'claude code query missing code capability');
+    assert(Array.isArray(claudeCodeHit.keywords) && claudeCodeHit.keywords.includes('claude_code'), 'claude code query missing keyword');
+
+    const sessionDetail = await api('session-detail', { source: 'codex', sessionId });
+    assert(Array.isArray(sessionDetail.messages), 'session-detail missing messages');
+
+    const sessionPlain = await api('session-plain', { source: 'codex', sessionId });
+    assert(sessionPlain.text && sessionPlain.text.includes('world'), 'session-plain missing content');
+
+    const sessionPlainMissing = await api('session-plain', { source: 'codex', sessionId: 'missing-session' });
+    assert(sessionPlainMissing.error, 'session-plain should fail for missing session');
+
+    const exportSession = await api('export-session', { source: 'codex', sessionId, maxMessages: 1 });
+    assert(exportSession.content, 'export-session missing content');
+    assert(exportSession.truncated === true, 'export-session should be truncated with maxMessages');
+
+    const cloneResult = await api('clone-session', { source: 'codex', sessionId });
+    assert(cloneResult.success === true, 'clone-session failed');
+    assert(cloneResult.sessionId && cloneResult.sessionId !== sessionId, 'clone-session id invalid');
+    assert(cloneResult.filePath && cloneResult.filePath.endsWith('.jsonl'), 'clone-session file path invalid');
+    assert(cloneResult.filePath && require('fs').existsSync(cloneResult.filePath), 'clone-session file missing');
+    const cloneSessionId = cloneResult.sessionId;
+
+    const cloneInvalid = await api('clone-session', { source: 'claude', sessionId });
+    assert(cloneInvalid.error, 'clone-session should reject non-codex source');
+
+    const apiSessionsAfterClone = await api('list-sessions', { source: 'codex', limit: 50, forceRefresh: true });
+    assert(Array.isArray(apiSessionsAfterClone.sessions), 'api sessions after clone missing');
+    assert(
+        apiSessionsAfterClone.sessions[0]
+        && apiSessionsAfterClone.sessions[0].sessionId === cloneSessionId,
+        'clone session not latest'
+    );
+
+    const deleteResult = await api('delete-session', { source: 'codex', sessionId });
+    assert(deleteResult.success === true, 'delete-session failed');
+
+    const deleteMissing = await api('delete-session', { source: 'codex', sessionId });
+    assert(deleteMissing.error, 'delete-session should fail for missing session');
+
+    const detailMissing = await api('session-detail', { source: 'codex', sessionId });
+    assert(detailMissing.error, 'session-detail should fail after delete');
+
+    const apiSessionsAfterDelete = await api('list-sessions', { source: 'codex', limit: 50, forceRefresh: true });
+    assert(!apiSessionsAfterDelete.sessions.some(item => item.sessionId === sessionId), 'deleted session still listed');
+    assert(apiSessionsAfterDelete.sessions.some(item => item.sessionId === cloneSessionId), 'clone session missing after delete');
+
+    Object.assign(ctx, { cloneSessionId });
+};
+

package/tests/e2e/test-setup.js

@@ -0,0 +1,159 @@
+const path = require('path');
+const fs = require('fs');
+const {
+    assert,
+    runSync,
+    runWithInput
+} = require('./helpers');
+
+module.exports = async function testSetup(ctx) {
+    const { env, node, cliPath, mockProviderUrl, noModelsUrl, htmlModelsUrl, authFailUrl, tmpHome } = ctx;
+
+    const setupInput = [
+        '2',
+        'e2e',
+        mockProviderUrl,
+        'sk-test',
+        'e2e-model',
+        ''
+    ].join('\n');
+
+    const setupResult = await runWithInput(node, [cliPath, 'setup'], setupInput, { env });
+    if (setupResult.status !== 0) {
+        const errorText = setupResult.stderr || setupResult.stdout || '';
+        if (errorText.includes('EPERM')) {
+            ctx.skipE2E = 'child_process spawn blocked (EPERM) during setup';
+            return;
+        }
+        assert(setupResult.status === 0, `setup failed: ${errorText}`);
+    }
+
+    const configPath = path.join(tmpHome, '.codex', 'config.toml');
+    assert(fs.existsSync(configPath), 'config.toml missing');
+    const configContent = fs.readFileSync(configPath, 'utf-8');
+    assert(/model_provider\s*=\s*"e2e"/.test(configContent), 'model_provider not set');
+    assert(/model\s*=\s*"e2e-model"/.test(configContent), 'model not set');
+    assert(/\[model_providers\.e2e\]/.test(configContent), 'provider block missing');
+    assert(configContent.includes(`base_url = "${mockProviderUrl}"`), 'base_url missing or mismatched');
+
+    const authPath = path.join(tmpHome, '.codex', 'auth.json');
+    const auth = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
+    assert(auth.OPENAI_API_KEY === 'sk-test', 'auth api_key mismatch');
+
+    const modelsPath = path.join(tmpHome, '.codex', 'models.json');
+    const models = JSON.parse(fs.readFileSync(modelsPath, 'utf-8'));
+    assert(models.includes('e2e-model'), 'custom model not added');
+
+    const statusResult = runSync(node, [cliPath, 'status'], { env });
+    assert(statusResult.status === 0, 'status failed');
+    assert(statusResult.stdout.includes('e2e'), 'status provider not shown');
+    assert(statusResult.stdout.includes('e2e-model'), 'status model not shown');
+
+    const listResult = runSync(node, [cliPath, 'list'], { env });
+    assert(listResult.status === 0, 'list failed');
+    assert(listResult.stdout.includes('e2e'), 'list missing provider');
+
+    const claudeModel = 'claude-e2e';
+    const claudeResult = runSync(node, [cliPath, 'claude', mockProviderUrl, 'sk-claude', claudeModel], { env });
+    assert(claudeResult.status === 0, `claude command failed: ${claudeResult.stderr || claudeResult.stdout}`);
+    const claudeSettingsPath = path.join(tmpHome, '.claude', 'settings.json');
+    assert(fs.existsSync(claudeSettingsPath), 'claude settings missing');
+    const claudeSettings = JSON.parse(fs.readFileSync(claudeSettingsPath, 'utf-8'));
+    assert(claudeSettings.env && claudeSettings.env.ANTHROPIC_API_KEY === 'sk-claude', 'claude API key mismatch');
+    assert(claudeSettings.env.ANTHROPIC_BASE_URL === mockProviderUrl, 'claude base url mismatch');
+    assert(claudeSettings.env.ANTHROPIC_MODEL === claudeModel, 'claude model mismatch');
+
+    const sessionsDir = path.join(tmpHome, '.codex', 'sessions');
+    fs.mkdirSync(sessionsDir, { recursive: true });
+    const sessionId = 'e2e-session';
+    const sessionPath = path.join(sessionsDir, `${sessionId}.jsonl`);
+    const sessionRecords = [
+        {
+            type: 'session_meta',
+            payload: { id: sessionId, cwd: '/tmp/e2e' },
+            timestamp: '2025-01-01T00:00:00.000Z'
+        },
+        {
+            type: 'response_item',
+            payload: { type: 'message', role: 'user', content: 'hello' },
+            timestamp: '2025-01-01T00:00:01.000Z'
+        },
+        {
+            type: 'response_item',
+            payload: { type: 'message', role: 'assistant', content: 'world' },
+            timestamp: '2025-01-01T00:00:02.000Z'
+        }
+    ];
+    fs.writeFileSync(sessionPath, sessionRecords.map(record => JSON.stringify(record)).join('\n') + '\n', 'utf-8');
+
+    const daudeSessionId = 'daude-e2e-session';
+    const daudeSessionPath = path.join(sessionsDir, `${daudeSessionId}.jsonl`);
+    const daudeRecords = [
+        {
+            type: 'session_meta',
+            payload: { id: daudeSessionId, cwd: '/tmp/daude' },
+            timestamp: '2025-02-02T00:00:00.000Z'
+        },
+        {
+            type: 'response_item',
+            payload: { type: 'message', role: 'user', content: 'daude code quick start 222' },
+            timestamp: '2025-02-02T00:00:01.000Z'
+        },
+        {
+            type: 'response_item',
+            payload: { type: 'message', role: 'assistant', content: 'sharing daude-code bootstrap' },
+            timestamp: '2025-02-02T00:00:02.000Z'
+        }
+    ];
+    fs.writeFileSync(daudeSessionPath, daudeRecords.map(record => JSON.stringify(record)).join('\n') + '\n', 'utf-8');
+
+    const claudeProjectsDir = path.join(tmpHome, '.claude', 'projects');
+    const claudeProjectDir = path.join(claudeProjectsDir, 'e2e-project');
+    fs.mkdirSync(claudeProjectDir, { recursive: true });
+    const claudeSessionId = 'claude-e2e-session';
+    const claudeSessionPath = path.join(claudeProjectDir, `${claudeSessionId}.jsonl`);
+    const claudeRecords = [
+        {
+            type: 'user',
+            message: { content: 'hello from claude code session' },
+            timestamp: '2025-02-01T00:00:00.000Z'
+        },
+        {
+            type: 'assistant',
+            message: { content: 'initialized project' },
+            timestamp: '2025-02-01T00:00:01.000Z'
+        }
+    ];
+    fs.writeFileSync(claudeSessionPath, claudeRecords.map(record => JSON.stringify(record)).join('\n') + '\n', 'utf-8');
+    const claudeIndexPath = path.join(claudeProjectDir, 'sessions-index.json');
+    const claudeIndex = {
+        entries: [
+            {
+                sessionId: claudeSessionId,
+                projectPath: claudeProjectDir,
+                fullPath: claudeSessionPath,
+                created: '2025-02-01T00:00:00.000Z',
+                modified: '2025-02-01T00:00:01.000Z',
+                summary: 'Claude Code sample session',
+                provider: 'claude',
+                capabilities: { code: true },
+                keywords: ['claude_code', 'sample'],
+                messageCount: 2
+            }
+        ]
+    };
+    fs.writeFileSync(claudeIndexPath, JSON.stringify(claudeIndex, null, 2), 'utf-8');
+
+    Object.assign(ctx, {
+        claudeModel,
+        sessionId,
+        sessionPath,
+        daudeSessionId,
+        daudeSessionPath,
+        claudeSessionId,
+        claudeSessionPath,
+        noModelsUrl,
+        htmlModelsUrl,
+        authFailUrl
+    });
+};

package/tests/unit/run.mjs

@@ -0,0 +1,29 @@
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const tests = [];
+globalThis.test = (name, fn) => tests.push({ name, fn });
+
+await import(pathToFileURL(path.join(__dirname, 'web-ui-logic.test.mjs')));
+
+let failures = 0;
+for (const { name, fn } of tests) {
+    try {
+        await fn();
+        console.log(`\u2713 ${name}`);
+    } catch (err) {
+        failures += 1;
+        console.error(`\u2717 ${name}`);
+        console.error(err);
+    }
+}
+
+if (failures) {
+    console.error(`Failed ${failures} test(s).`);
+    process.exit(1);
+} else {
+    console.log(`All ${tests.length} tests passed.`);
+}