codexmate 0.0.5 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
-{
+{
   "name": "codexmate",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Codex/Claude Code 配置与会话管理 CLI + Web 工具",
   "bin": {
     "codexmate": "./cli.js"
@@ -11,7 +11,8 @@
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",
-    "json5": "^2.2.3"
+    "json5": "^2.2.3",
+    "zip-lib": "^1.2.1"
   },
   "engines": {
     "node": ">=14"

package/tests/e2e/recent-health.e2e.js

@@ -1,135 +1,136 @@
-const http = require('http');
-const path = require('path');
-const os = require('os');
-const fs = require('fs');
-const { spawn } = require('child_process');
-
-const PORT = 3737;
-const API_URL = `http://localhost:${PORT}/api`;
-
-function delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-function request(action, params = {}) {
-    const payload = JSON.stringify({ action, params });
-    return new Promise((resolve, reject) => {
-        const req = http.request(API_URL, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Content-Length': Buffer.byteLength(payload)
-            }
-        }, (res) => {
-            let data = '';
-            res.on('data', chunk => data += chunk);
-            res.on('end', () => {
-                try {
-                    const json = JSON.parse(data || '{}');
-                    resolve(json);
-                } catch (e) {
-                    reject(e);
-                }
-            });
-        });
-        req.on('error', reject);
-        req.write(payload);
-        req.end();
-    });
-}
-
-async function waitForServer(timeoutMs = 12000) {
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-        try {
-            await request('status');
-            return;
-        } catch (_) {
-            await delay(300);
-        }
-    }
-    throw new Error('server not ready');
-}
-
-function escapeToml(value) {
-    return String(value || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-}
-
-function buildTemplate(provider, model, baseUrl, apiKey) {
-    return `model_provider = "${escapeToml(provider)}"
-model = "${escapeToml(model)}"
-
-[model_providers.${escapeToml(provider)}]
-name = "${escapeToml(provider)}"
-base_url = "${escapeToml(baseUrl)}"
-wire_api = "responses"
-preferred_auth_method = "${escapeToml(apiKey)}"
-`;
-}
-
-function assert(condition, message) {
-    if (!condition) {
-        throw new Error(`Assertion failed: ${message}`);
-    }
-}
-
-async function run() {
-    const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'codexmate-e2e-'));
-    const env = {
-        ...process.env,
-        USERPROFILE: tempHome,
-        HOME: tempHome,
-        CODEXMATE_NO_BROWSER: '1'
-    };
-
-    const cliPath = path.join(__dirname, '..', '..', 'cli.js');
-    const child = spawn(process.execPath, [cliPath, 'start'], {
-        env,
-        stdio: ['ignore', 'pipe', 'pipe']
-    });
-
-    try {
-        await waitForServer();
-
-        await request('apply-config-template', { template: buildTemplate('alpha', 'm-alpha', 'https://example.com', 'sk-alpha') });
-        await request('apply-config-template', { template: buildTemplate('beta', 'm-beta', 'https://example.com', 'sk-beta') });
-        await request('apply-config-template', { template: buildTemplate('gamma', 'm-gamma', 'https://example.com', 'sk-gamma') });
-        await request('apply-config-template', { template: buildTemplate('delta', 'm-delta', 'https://example.com', 'sk-delta') });
-
-        const recent = await request('get-recent-configs');
-        assert(Array.isArray(recent.items), 'recent list should be array');
-        assert(recent.items.length === 3, 'recent list should keep 3 items');
-        assert(recent.items[0].provider === 'delta' && recent.items[0].model === 'm-delta', 'recent[0] should be delta');
-        assert(recent.items[1].provider === 'gamma' && recent.items[1].model === 'm-gamma', 'recent[1] should be gamma');
-        assert(recent.items[2].provider === 'beta' && recent.items[2].model === 'm-beta', 'recent[2] should be beta');
-
-        await request('apply-config-template', { template: buildTemplate('broken', 'm-broken', 'not-a-url', '') });
-        await request('delete-model', { model: 'm-broken' });
-
-        const health = await request('config-health-check');
-        assert(health && Array.isArray(health.issues), 'health check issues should be array');
-        const codes = new Set(health.issues.map(item => item.code));
-        assert(codes.has('base-url-invalid'), 'health check should flag invalid URL');
-        assert(codes.has('api-key-missing'), 'health check should flag missing key');
-        assert(codes.has('model-unavailable'), 'health check should flag missing model');
-
-        await request('apply-config-template', {
-            template: buildTemplate('local', 'm-local', `http://127.0.0.1:${PORT}`, 'sk-local')
-        });
-        const remoteHealth = await request('config-health-check', { remote: true, timeoutMs: 2000 });
-        assert(remoteHealth && Array.isArray(remoteHealth.issues), 'remote health issues should be array');
-        const remoteCodes = new Set(remoteHealth.issues.map(item => item.code));
-        assert(remoteCodes.has('remote-models-parse'), 'remote health should flag models parse error');
-    } finally {
-        if (child && !child.killed) {
-            child.kill('SIGINT');
-        }
-        await delay(300);
-        fs.rmSync(tempHome, { recursive: true, force: true });
-    }
-}
-
-run().catch((err) => {
-    console.error(err);
-    process.exit(1);
-});
+const http = require('http');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const { spawn } = require('child_process');
+
+const PORT = 3737;
+const API_URL = `http://localhost:${PORT}/api`;
+
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function request(action, params = {}) {
+    const payload = JSON.stringify({ action, params });
+    return new Promise((resolve, reject) => {
+        const req = http.request(API_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload)
+            }
+        }, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data || '{}');
+                    resolve(json);
+                } catch (e) {
+                    reject(e);
+                }
+            });
+        });
+        req.on('error', reject);
+        req.write(payload);
+        req.end();
+    });
+}
+
+async function waitForServer(timeoutMs = 12000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            await request('status');
+            return;
+        } catch (_) {
+            await delay(300);
+        }
+    }
+    throw new Error('server not ready');
+}
+
+function escapeToml(value) {
+    return String(value || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function buildTemplate(provider, model, baseUrl, apiKey) {
+    return `model_provider = "${escapeToml(provider)}"
+model = "${escapeToml(model)}"
+
+[model_providers.${escapeToml(provider)}]
+name = "${escapeToml(provider)}"
+base_url = "${escapeToml(baseUrl)}"
+wire_api = "responses"
+preferred_auth_method = "${escapeToml(apiKey)}"
+`;
+}
+
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(`Assertion failed: ${message}`);
+    }
+}
+
+async function run() {
+    const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'codexmate-e2e-'));
+    const env = {
+        ...process.env,
+        USERPROFILE: tempHome,
+        HOME: tempHome,
+        CODEXMATE_NO_BROWSER: '1'
+    };
+
+    const cliPath = path.join(__dirname, '..', '..', 'cli.js');
+    const child = spawn(process.execPath, [cliPath, 'start'], {
+        env,
+        stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    try {
+        await waitForServer();
+
+        await request('apply-config-template', { template: buildTemplate('alpha', 'm-alpha', 'https://example.com', 'sk-alpha') });
+        await request('apply-config-template', { template: buildTemplate('beta', 'm-beta', 'https://example.com', 'sk-beta') });
+        await request('apply-config-template', { template: buildTemplate('gamma', 'm-gamma', 'https://example.com', 'sk-gamma') });
+        await request('apply-config-template', { template: buildTemplate('delta', 'm-delta', 'https://example.com', 'sk-delta') });
+
+        const recent = await request('get-recent-configs');
+        assert(Array.isArray(recent.items), 'recent list should be array');
+        assert(recent.items.length === 3, 'recent list should keep 3 items');
+        assert(recent.items[0].provider === 'delta' && recent.items[0].model === 'm-delta', 'recent[0] should be delta');
+        assert(recent.items[1].provider === 'gamma' && recent.items[1].model === 'm-gamma', 'recent[1] should be gamma');
+        assert(recent.items[2].provider === 'beta' && recent.items[2].model === 'm-beta', 'recent[2] should be beta');
+
+        await request('apply-config-template', { template: buildTemplate('broken', 'm-broken', 'not-a-url', '') });
+        await request('delete-model', { model: 'm-broken' });
+
+        const health = await request('config-health-check');
+        assert(health && Array.isArray(health.issues), 'health check issues should be array');
+        const codes = new Set(health.issues.map(item => item.code));
+        assert(codes.has('base-url-invalid'), 'health check should flag invalid URL');
+        assert(codes.has('api-key-missing'), 'health check should flag missing key');
+        assert(codes.has('model-unavailable'), 'health check should flag missing model');
+
+        await request('apply-config-template', {
+            template: buildTemplate('local', 'm-local', `http://127.0.0.1:${PORT}`, 'sk-local')
+        });
+        const remoteHealth = await request('config-health-check', { remote: true, timeoutMs: 2000 });
+        assert(remoteHealth && Array.isArray(remoteHealth.issues), 'remote health issues should be array');
+        assert(remoteHealth.ok === true, 'remote health should pass');
+        assert(remoteHealth.remote && remoteHealth.remote.type === 'speed-test', 'remote health should include speed-test info');
+        assert(typeof remoteHealth.remote.durationMs === 'number', 'remote health should include duration');
+    } finally {
+        if (child && !child.killed) {
+            child.kill('SIGINT');
+        }
+        await delay(300);
+        fs.rmSync(tempHome, { recursive: true, force: true });
+    }
+}
+
+run().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/tests/e2e/run.js

@@ -178,6 +178,29 @@ async function main() {
         const models = JSON.parse(fs.readFileSync(modelsPath, 'utf-8'));
         assert(models.includes('e2e-model'), 'custom model not added');
 
+        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 statusResult = runSync(node, [cliPath, 'status'], { env });
         assert(statusResult.status === 0, 'status failed');
         assert(statusResult.stdout.includes('提供商: e2e'), 'status provider not shown');
@@ -255,6 +278,46 @@ async function main() {
             });
             assert(apiModelsByUrlUnlimited.unlimited === true, 'api models-by-url unlimited missing');
 
+            const apiSessions = await postJson(port, {
+                action: 'list-sessions',
+                params: { 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 cloneResult = await postJson(port, {
+                action: 'clone-session',
+                params: { source: 'codex', sessionId }
+            });
+            assert(cloneResult.success === true, 'clone-session failed');
+            assert(cloneResult.sessionId && cloneResult.sessionId !== sessionId, 'clone-session id invalid');
+            assert(fs.existsSync(cloneResult.filePath), 'clone-session file missing');
+
+            const apiSessionsAfterClone = await postJson(port, {
+                action: 'list-sessions',
+                params: { source: 'codex', limit: 50, forceRefresh: true }
+            });
+            assert(Array.isArray(apiSessionsAfterClone.sessions), 'api sessions after clone missing');
+            assert(
+                apiSessionsAfterClone.sessions[0]
+                    && apiSessionsAfterClone.sessions[0].sessionId === cloneResult.sessionId,
+                'clone session not latest'
+            );
+
+            const deleteResult = await postJson(port, {
+                action: 'delete-session',
+                params: { source: 'codex', sessionId }
+            });
+            assert(deleteResult.success === true, 'delete-session failed');
+            assert(!fs.existsSync(sessionPath), 'delete-session file still exists');
+
+            const apiSessionsAfterDelete = await postJson(port, {
+                action: 'list-sessions',
+                params: { 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 === cloneResult.sessionId), 'clone session missing after delete');
+
             const speedResult = await postJson(port, { action: 'speed-test', params: { name: 'e2e2' } }, 4000);
             assert(speedResult.ok === true, 'speed-test failed');