codexmate 0.0.9 → 0.0.12

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

@@ -1,142 +0,0 @@
-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 share = await request('export-provider', { name: 'delta' });
-        assert(share && share.payload, 'share payload should exist');
-        assert(share.payload.name === 'delta', 'share name should be delta');
-        assert(share.payload.baseUrl === 'https://example.com', 'share baseUrl mismatch');
-        assert(share.payload.apiKey === 'sk-delta', 'share apiKey mismatch');
-
-        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

@@ -1,154 +0,0 @@
-const { spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const {
-    os,
-    debug,
-    captureFileState,
-    assertFileUnchanged,
-    startLocalServer,
-    closeServer,
-    waitForServer,
-    postJson
-} = require('./helpers');
-
-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');
-
-async function main() {
-    const realHome = os.homedir();
-    const realCodexDir = path.join(realHome, '.codex');
-    const realFileStates = [
-        captureFileState(path.join(realCodexDir, 'config.toml')),
-        captureFileState(path.join(realCodexDir, 'auth.json')),
-        captureFileState(path.join(realCodexDir, 'models.json')),
-        captureFileState(path.join(realCodexDir, 'provider-current-models.json'))
-    ];
-
-    const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'codexmate-e2e-'));
-    const env = {
-        ...process.env,
-        HOME: tmpHome,
-        USERPROFILE: tmpHome,
-        CODEXMATE_FORCE_RESET_EXISTING_CONFIG: '1'
-    };
-    const cliPath = path.resolve(__dirname, '../../cli.js');
-    const node = process.execPath;
-
-    debug('setup start');
-    let mockProvider;
-    let noModelsProvider;
-    let htmlModelsProvider;
-    let authFailProvider;
-    let webServer;
-    try {
-        mockProvider = await startLocalServer({ mode: 'list', modelsPath: '/v1/models' });
-        noModelsProvider = await startLocalServer({ mode: 'none', modelsPath: '/v1/models' });
-        htmlModelsProvider = await startLocalServer({ mode: 'html', modelsPath: '/v1/models' });
-        authFailProvider = await startLocalServer({ mode: 'list', modelsPath: '/v1/models', status: 401 });
-
-        const mockProviderUrl = `http://127.0.0.1:${mockProvider.port}`;
-        const noModelsUrl = `http://127.0.0.1:${noModelsProvider.port}`;
-        const htmlModelsUrl = `http://127.0.0.1:${htmlModelsProvider.port}`;
-        const authFailUrl = `http://127.0.0.1:${authFailProvider.port}`;
-
-        const ctx = {
-            env,
-            node,
-            cliPath,
-            tmpHome,
-            mockProviderUrl,
-            noModelsUrl,
-            htmlModelsUrl,
-            authFailUrl
-        };
-
-        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');
-        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', () => {});
-
-        await waitForServer(port);
-        debug('server ready');
-
-        const api = (action, params, timeoutMs) => postJson(port, { action, params }, timeoutMs);
-        Object.assign(ctx, { port, api });
-
-        await testConfig(ctx);
-        await testClaude(ctx);
-        await testSessionSearch(ctx);
-        await testSessions(ctx);
-        await testOpenclaw(ctx);
-        await testHealthSpeed(ctx);
-
-    } finally {
-        const waitForExit = new Promise((resolve) => {
-            if (!webServer) return resolve();
-            const forceKill = setTimeout(() => {
-                try {
-                    webServer.kill('SIGKILL');
-                } catch (e) {}
-            }, 2000);
-            webServer.once('exit', () => {
-                clearTimeout(forceKill);
-                resolve();
-            });
-            if (webServer.exitCode !== null || webServer.signalCode) {
-                clearTimeout(forceKill);
-                resolve();
-            }
-        });
-        try {
-            if (webServer) {
-                webServer.kill('SIGINT');
-            }
-        } catch (e) {}
-        await waitForExit;
-
-        await closeServer(mockProvider && mockProvider.server);
-        await closeServer(noModelsProvider && noModelsProvider.server);
-        await closeServer(htmlModelsProvider && htmlModelsProvider.server);
-        await closeServer(authFailProvider && authFailProvider.server);
-
-        for (const state of realFileStates) {
-            const label = state && state.path ? path.basename(state.path) : 'real file';
-            assertFileUnchanged(state, `real ${label}`);
-        }
-        try {
-            if (fs.rmSync) {
-                fs.rmSync(tmpHome, { recursive: true, force: true });
-            } else {
-                fs.rmdirSync(tmpHome, { recursive: true });
-            }
-        } catch (e) {}
-    }
-}
-
-main().catch((err) => {
-    console.error('E2E failed:', err.message || err);
-    process.exit(1);
-});

package/tests/e2e/test-claude.js

@@ -1,21 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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');
-};