codexmate 0.0.8 → 0.0.9

package/tests/e2e/run.js

@@ -15,6 +15,7 @@ const {
 const testSetup = require('./test-setup');
 const testConfig = require('./test-config');
 const testClaude = require('./test-claude');
+const testSessionSearch = require('./test-session-search');
 const testSessions = require('./test-sessions');
 const testOpenclaw = require('./test-openclaw');
 const testHealthSpeed = require('./test-health-speed');
@@ -68,13 +69,26 @@ async function main() {
         };
 
         await testSetup(ctx);
+        if (ctx.skipE2E) {
+            console.warn(`E2E skipped: ${ctx.skipE2E}`);
+            return;
+        }
 
         const port = 18000 + Math.floor(Math.random() * 1000);
         debug('start web server');
-        webServer = spawn(node, [cliPath, 'run'], {
-            env: { ...env, CODEXMATE_PORT: String(port) },
-            stdio: ['ignore', 'pipe', 'pipe']
-        });
+        try {
+            webServer = spawn(node, [cliPath, 'run'], {
+                env: { ...env, CODEXMATE_PORT: String(port) },
+                stdio: ['ignore', 'pipe', 'pipe']
+            });
+        } catch (err) {
+            if (err && err.code === 'EPERM') {
+                console.warn('E2E skipped: child_process spawn blocked (EPERM) when starting server');
+                ctx.skipE2E = ctx.skipE2E || 'child_process spawn blocked (EPERM) when starting server';
+                return;
+            }
+            throw err;
+        }
         webServer.stdout.on('data', () => {});
         webServer.stderr.on('data', () => {});
 
@@ -86,6 +100,7 @@ async function main() {
 
         await testConfig(ctx);
         await testClaude(ctx);
+        await testSessionSearch(ctx);
         await testSessions(ctx);
         await testOpenclaw(ctx);
         await testHealthSpeed(ctx);

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

@@ -71,5 +71,9 @@ module.exports = async function testHealthAndSpeed(ctx) {
 
     const newPath = path.join(permDir, 'new.json');
     writeJsonAtomic(newPath, { b: 1 });
-    assert(fileMode(newPath) === 0o600, 'writeJsonAtomic should default to 600 for new file');
+    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-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

@@ -1,19 +1,27 @@
-const path = require('path');
+const path = require('path');
 const { assert } = require('./helpers');
 
 module.exports = async function testSessions(ctx) {
-    const { api, sessionId, tmpHome } = 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 apiSessionsAll = await api('list-sessions', { source: 'all', limit: 50, forceRefresh: true });
-    assert(Array.isArray(apiSessionsAll.sessions), 'api sessions(all) missing');
-    assert(apiSessionsAll.sessions.some(item => item.sessionId === sessionId), 'api sessions(all) missing codex entry');
-
-    const sessionDetail = await api('session-detail', { source: 'codex', sessionId });
-    assert(Array.isArray(sessionDetail.messages), 'session-detail missing messages');
+    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');
@@ -58,3 +66,4 @@ module.exports = async function testSessions(ctx) {
 
     Object.assign(ctx, { cloneSessionId });
 };
+

package/tests/e2e/test-setup.js

@@ -19,7 +19,14 @@ module.exports = async function testSetup(ctx) {
     ].join('\n');
 
     const setupResult = await runWithInput(node, [cliPath, 'setup'], setupInput, { env });
-    assert(setupResult.status === 0, `setup failed: ${setupResult.stderr || setupResult.stdout}`);
+    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');
@@ -56,11 +63,11 @@ module.exports = async function testSetup(ctx) {
     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 = [
+    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' },
@@ -76,15 +83,77 @@ module.exports = async function testSetup(ctx) {
             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(sessionPath, sessionRecords.map(record => JSON.stringify(record)).join('\n') + '\n', 'utf-8');
+    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,
-        noModelsUrl,
-        htmlModelsUrl,
-        authFailUrl
+    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.`);
+}

package/tests/unit/web-ui-logic.test.mjs

@@ -0,0 +1,186 @@
+import assert from 'assert';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const logic = await import(pathToFileURL(path.join(__dirname, '..', '..', 'web-ui', 'logic.mjs')));
+const {
+    normalizeClaudeValue,
+    normalizeClaudeConfig,
+    normalizeClaudeSettingsEnv,
+    matchClaudeConfigFromSettings,
+    findDuplicateClaudeConfigName,
+    formatLatency,
+    buildSpeedTestIssue,
+    isSessionQueryEnabled,
+    buildSessionListParams
+} = logic;
+
+test('normalizeClaudeValue trims strings and ignores non-string', () => {
+    assert.strictEqual(normalizeClaudeValue('  abc  '), 'abc');
+    assert.strictEqual(normalizeClaudeValue(123), '');
+    assert.strictEqual(normalizeClaudeValue(null), '');
+});
+
+test('normalizeClaudeConfig trims all fields', () => {
+    const cfg = normalizeClaudeConfig({ apiKey: ' key ', baseUrl: ' url ', model: ' model ' });
+    assert.deepStrictEqual(cfg, { apiKey: 'key', baseUrl: 'url', model: 'model' });
+});
+
+test('normalizeClaudeSettingsEnv trims settings env', () => {
+    const env = { ANTHROPIC_API_KEY: ' key ', ANTHROPIC_BASE_URL: ' url ', ANTHROPIC_MODEL: ' model ' };
+    assert.deepStrictEqual(normalizeClaudeSettingsEnv(env), { apiKey: 'key', baseUrl: 'url', model: 'model' });
+});
+
+test('normalizeClaudeSettingsEnv fills missing fields with empty strings', () => {
+    const env = { ANTHROPIC_API_KEY: 'k' };
+    assert.deepStrictEqual(normalizeClaudeSettingsEnv(env), { apiKey: 'k', baseUrl: '', model: '' });
+});
+
+test('matchClaudeConfigFromSettings matches identical config', () => {
+    const configs = { default: { apiKey: 'k', baseUrl: 'u', model: 'm' } };
+    const env = { ANTHROPIC_API_KEY: 'k', ANTHROPIC_BASE_URL: 'u', ANTHROPIC_MODEL: 'm' };
+    assert.strictEqual(matchClaudeConfigFromSettings(configs, env), 'default');
+});
+
+test('matchClaudeConfigFromSettings returns empty when incomplete', () => {
+    const configs = { default: { apiKey: 'k', baseUrl: 'u', model: 'm' } };
+    const env = { ANTHROPIC_API_KEY: 'k', ANTHROPIC_BASE_URL: '', ANTHROPIC_MODEL: 'm' };
+    assert.strictEqual(matchClaudeConfigFromSettings(configs, env), '');
+});
+
+test('findDuplicateClaudeConfigName returns empty on missing fields', () => {
+    const configs = { only: { apiKey: 'k', baseUrl: 'u', model: 'm' } };
+    const incomplete = { apiKey: 'k', baseUrl: '', model: '' };
+    assert.strictEqual(findDuplicateClaudeConfigName(configs, incomplete), '');
+});
+
+test('findDuplicateClaudeConfigName detects duplicates', () => {
+    const configs = {
+        first: { apiKey: 'k1', baseUrl: 'u1', model: 'm1' },
+        second: { apiKey: 'k2', baseUrl: 'u2', model: 'm2' }
+    };
+    const duplicate = { apiKey: 'k2', baseUrl: 'u2', model: 'm2' };
+    assert.strictEqual(findDuplicateClaudeConfigName(configs, duplicate), 'second');
+});
+
+test('findDuplicateClaudeConfigName returns empty when no match', () => {
+    const configs = { only: { apiKey: 'k', baseUrl: 'u', model: 'm' } };
+    const another = { apiKey: 'k', baseUrl: 'u', model: 'm-2' };
+    assert.strictEqual(findDuplicateClaudeConfigName(configs, another), '');
+});
+
+test('formatLatency formats success and errors', () => {
+    assert.strictEqual(formatLatency({ ok: true, durationMs: 120 }), '120ms');
+    assert.strictEqual(formatLatency({ ok: false, status: 404 }), 'ERR 404');
+    assert.strictEqual(formatLatency({ ok: false }), 'ERR');
+    assert.strictEqual(formatLatency(null), '');
+    assert.strictEqual(formatLatency({ ok: true, durationMs: undefined }), '0ms');
+    assert.strictEqual(formatLatency({ ok: true, durationMs: '12' }), '0ms');
+});
+
+test('buildSpeedTestIssue maps errors and status codes', () => {
+    assert.strictEqual(buildSpeedTestIssue('p1', null), null);
+    const missing = buildSpeedTestIssue('p1', { error: 'Provider not found' });
+    assert.strictEqual(missing.code, 'remote-speedtest-provider-missing');
+
+    const timeout = buildSpeedTestIssue('p1', { error: 'Request timeout' });
+    assert.strictEqual(timeout.code, 'remote-speedtest-timeout');
+
+    const auth = buildSpeedTestIssue('p1', { ok: false, status: 401 });
+    assert.strictEqual(auth.code, 'remote-speedtest-auth-failed');
+
+    const httpErr = buildSpeedTestIssue('p1', { ok: false, status: 500 });
+    assert.strictEqual(httpErr.code, 'remote-speedtest-http-error');
+
+    const ok = buildSpeedTestIssue('p1', { ok: true, status: 200 });
+    assert.strictEqual(ok, null);
+
+    const invalidUrl = buildSpeedTestIssue('p1', { error: 'Invalid URL' });
+    assert.strictEqual(invalidUrl.code, 'remote-speedtest-invalid-url');
+
+    const missingUrl = buildSpeedTestIssue('p1', { error: 'Missing name or url' });
+    assert.strictEqual(missingUrl.code, 'remote-speedtest-baseurl-missing');
+
+    const timeoutLower = buildSpeedTestIssue('p1', { error: 'timeout while fetching' });
+    assert.strictEqual(timeoutLower.code, 'remote-speedtest-timeout');
+
+    const generic = buildSpeedTestIssue('p1', { error: 'network unreachable' });
+    assert.strictEqual(generic.code, 'remote-speedtest-unreachable');
+
+    const auth403 = buildSpeedTestIssue('p1', { ok: false, status: 403 });
+    assert.strictEqual(auth403.code, 'remote-speedtest-auth-failed');
+
+    const http400 = buildSpeedTestIssue('p1', { ok: false, status: 400 });
+    assert.strictEqual(http400.code, 'remote-speedtest-http-error');
+});
+
+test('isSessionQueryEnabled supports codex and claude only', () => {
+    assert.strictEqual(isSessionQueryEnabled('codex'), true);
+    assert.strictEqual(isSessionQueryEnabled('CODEX'), true);
+    assert.strictEqual(isSessionQueryEnabled('claude'), true);
+    assert.strictEqual(isSessionQueryEnabled('ALL'), false);
+    assert.strictEqual(isSessionQueryEnabled('openai'), false);
+    assert.strictEqual(isSessionQueryEnabled(''), false);
+});
+
+test('buildSessionListParams keeps claude code lexicon query when enabled', () => {
+    const paramsClaude = buildSessionListParams({
+        source: 'claude',
+        query: 'claude code',
+        roleFilter: 'all'
+    });
+    assert.strictEqual(paramsClaude.query, 'claude code');
+    assert.strictEqual(paramsClaude.queryMode, 'and');
+    assert.strictEqual(paramsClaude.queryScope, 'content');
+});
+
+test('buildSessionListParams keeps query for enabled sources', () => {
+    const paramsCodex = buildSessionListParams({
+        source: 'codex',
+        query: 'test',
+        pathFilter: ''
+    });
+    assert.strictEqual(paramsCodex.query, 'test');
+    assert.strictEqual(paramsCodex.source, 'codex');
+    assert.strictEqual(paramsCodex.limit, 200);
+
+    const paramsClaude = buildSessionListParams({
+        source: 'claude',
+        query: 'claude code',
+        roleFilter: 'user'
+    });
+    assert.strictEqual(paramsClaude.query, 'claude code');
+    assert.strictEqual(paramsClaude.source, 'claude');
+    assert.strictEqual(paramsClaude.roleFilter, 'user');
+    assert.strictEqual(paramsClaude.limit, 200);
+
+    const paramsAll = buildSessionListParams({
+        source: 'codex',
+        query: 'claudecode',
+        timeRangePreset: '7d'
+    });
+    assert.strictEqual(paramsAll.query, 'claudecode');
+    assert.strictEqual(paramsAll.source, 'codex');
+    assert.strictEqual(paramsAll.timeRangePreset, '7d');
+    assert.strictEqual(paramsAll.limit, 200);
+});
+
+test('buildSessionListParams clears query for unsupported sources', () => {
+    const params = buildSessionListParams({
+        source: 'openai',
+        query: 'hello',
+        pathFilter: '/tmp',
+        roleFilter: 'assistant'
+    });
+    assert.strictEqual(params.query, '');
+    assert.strictEqual(params.source, 'openai');
+    assert.strictEqual(params.pathFilter, '/tmp');
+    assert.strictEqual(params.roleFilter, 'assistant');
+    assert.strictEqual(params.limit, 200);
+    assert.strictEqual(params.forceRefresh, true);
+    assert.strictEqual(params.queryScope, 'content');
+    assert.strictEqual(params.contentScanLimit, 50);
+});