codexmate 0.0.6 → 0.0.8

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,75 @@
+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 });
+    assert(fileMode(newPath) === 0o600, 'writeJsonAtomic should default to 600 for new file');
+};

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-sessions.js

@@ -0,0 +1,60 @@
+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 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,90 @@
+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 });
+    assert(setupResult.status === 0, `setup failed: ${setupResult.stderr || setupResult.stdout}`);
+
+    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');
+
+    Object.assign(ctx, {
+        claudeModel,
+        sessionId,
+        sessionPath,
+        noModelsUrl,
+        htmlModelsUrl,
+        authFailUrl
+    });
+};