codexmate 0.0.55 → 0.0.57

package/lib/task-orchestrator.js

@@ -1,3 +1,5 @@
+const OPENAI_CHAT_TRANSIENT_RETRY_LIMIT = 2;
+
 function isPlainObject(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
@@ -100,6 +102,23 @@ function buildTaskTitle(target, explicitTitle = '') {
     return truncateText(normalizedTarget.replace(/\s+/g, ' '), 96);
 }
 
+
+function normalizeTaskEngine(value) {
+    const normalized = normalizeId(value, 'openai-chat');
+    if (normalized === 'workflow') return 'workflow';
+    // Legacy plans used the name `codex`; the execution base is now OpenAI Chat compatible.
+    return 'openai-chat';
+}
+
+function normalizeTaskNodeKind(value) {
+    const normalized = normalizeId(value, '');
+    if (!normalized) return '';
+    if (normalized === 'workflow') return 'workflow';
+    if (normalized === 'codex') return 'openai-chat';
+    if (normalized === 'openai' || normalized === 'openai-chat' || normalized === 'chat') return 'openai-chat';
+    return normalized;
+}
+
 function normalizeDependencyIds(value = []) {
     return uniqueStringList(value)
         .map((depId) => normalizeId(depId, ''))
@@ -193,11 +212,15 @@ function detectDependencyCycle(nodes = []) {
     return false;
 }
 
-function buildCodexNodePrompt(kind, context = {}) {
+const PLAN_DISCUSSION_PREFIX = '我们先探讨方案，在我让你生成之前不要生成';
+
+function buildOpenAiChatNodePrompt(kind, context = {}) {
     const title = normalizeText(context.title, 160);
     const target = normalizeText(context.target, 4000);
     const item = normalizeText(context.item, 1200);
     const followUp = normalizeText(context.followUp, 1200);
+    const followUps = uniqueStringList(context.followUps || []).slice(0, 8);
+    const cwd = normalizeText(context.cwd, 1200);
     const dependencySummaries = uniqueStringList(context.dependencySummaries || []).slice(0, 6);
     const allowWrite = context.allowWrite === true;
     const dependencyBlock = dependencySummaries.length > 0
@@ -206,10 +229,12 @@ function buildCodexNodePrompt(kind, context = {}) {
     const writeRule = allowWrite
         ? '允许直接修改本地工作区，但必须控制变更范围并完成最小必要验证。'
         : '只允许只读调查，不要修改任何文件，不要执行写入型操作。';
+    const cwdLine = cwd ? `工作区路径: ${cwd}` : '';
 
     if (kind === 'analysis') {
         return [
             `任务标题: ${title || '任务分析'}`,
+            cwdLine,
             `任务目标:\n${target}`,
             writeRule,
             '请先调查当前仓库与上下文，给出简洁的现状判断、主要风险、建议执行顺序，以及你认为最小可行的验证方案。',
@@ -217,9 +242,25 @@ function buildCodexNodePrompt(kind, context = {}) {
         ].join('\n\n');
     }
 
+    if (kind === 'plan') {
+        const userDemand = [PLAN_DISCUSSION_PREFIX, target].filter(Boolean).join('\n\n');
+        const followUpBlock = followUps.length > 0
+            ? `\n补充需求:\n${followUps.map((entry, index) => `${index + 1}. ${entry}`).join('\n')}`
+            : '';
+        return [
+            `任务标题: ${title || '方案草拟'}`,
+            cwdLine,
+            `任务需求:\n${userDemand}`,
+            followUpBlock,
+            '请只输出可讨论、可确认的执行方案：目标拆解、建议步骤、风险点、需要用户确认的问题。',
+            '不要修改文件、不要启动实际执行，也不要把“等待用户确认”拆成依赖执行链。'
+        ].filter(Boolean).join('\n\n');
+    }
+
     if (kind === 'work') {
         return [
             `任务标题: ${title || '执行子任务'}`,
+            cwdLine,
             `总目标:\n${target}`,
             `当前子任务:\n${item || title || target}`,
             dependencyBlock,
@@ -231,6 +272,7 @@ function buildCodexNodePrompt(kind, context = {}) {
     if (kind === 'verify') {
         return [
             `任务标题: ${title || '验证与总结'}`,
+            cwdLine,
             `总目标:\n${target}`,
             dependencyBlock,
             writeRule,
@@ -240,6 +282,7 @@ function buildCodexNodePrompt(kind, context = {}) {
 
     return [
         `任务标题: ${title || '后续任务'}`,
+        cwdLine,
         `总目标:\n${target}`,
         dependencyBlock,
         writeRule,
@@ -267,7 +310,7 @@ function buildTaskPlan(request = {}, options = {}) {
     const workflowMap = normalizeWorkflowCatalog(options.workflowCatalog || []);
     const target = normalizeText(request.target, 4000);
     const title = buildTaskTitle(target, request.title);
-    const engine = normalizeId(request.engine, 'codex') === 'workflow' ? 'workflow' : 'codex';
+    const requestedEngine = normalizeTaskEngine(request.engine);
     const allowWrite = request.allowWrite === true;
     const dryRun = request.dryRun === true;
     const concurrency = normalizePositiveInteger(request.concurrency, 2, 1, 8);
@@ -278,12 +321,33 @@ function buildTaskPlan(request = {}, options = {}) {
     const followUps = uniqueStringList(request.followUps || []);
     const notes = normalizeText(request.notes, 2000);
     const cwd = normalizeText(request.cwd || options.cwd, 1200);
+    const threadId = normalizeText(request.threadId || request.conversationId || request.sessionId, 160);
     const nodes = [];
     let nodeSequence = 0;
     const nextNodeId = (prefix) => `${prefix}-${String(++nodeSequence).padStart(2, '0')}`;
-    const shouldBuildWorkflowNodes = requestedWorkflowIds.length > 0 || engine === 'workflow';
+    const shouldBuildWorkflowNodes = requestedWorkflowIds.length > 0 || requestedEngine === 'workflow';
+    const engine = shouldBuildWorkflowNodes ? 'workflow' : requestedEngine;
+    const previewOnly = request.previewOnly === true && !shouldBuildWorkflowNodes;
 
-    if (shouldBuildWorkflowNodes) {
+    if (previewOnly) {
+        const previewId = nextNodeId('plan');
+        nodes.push({
+            id: previewId,
+            title: '方案草拟',
+            kind: 'openai-chat',
+            prompt: buildOpenAiChatNodePrompt('plan', {
+                title,
+                target,
+                followUps,
+                cwd,
+                allowWrite: false
+            }),
+            dependsOn: [],
+            write: false,
+            retryLimit: 0,
+            autoFixRounds: 0
+        });
+    } else if (shouldBuildWorkflowNodes) {
         let previousId = '';
         for (const workflowId of requestedWorkflowIds) {
             const meta = workflowMap.get(workflowId);
@@ -313,15 +377,16 @@ function buildTaskPlan(request = {}, options = {}) {
         nodes.push({
             id: analysisId,
             title: '现状分析',
-            kind: 'codex',
-            prompt: buildCodexNodePrompt('analysis', {
+            kind: 'openai-chat',
+            prompt: buildOpenAiChatNodePrompt('analysis', {
                 title,
                 target,
+                cwd,
                 allowWrite: false
             }),
             dependsOn: [],
             write: false,
-            retryLimit: 0,
+            retryLimit: OPENAI_CHAT_TRANSIENT_RETRY_LIMIT,
             autoFixRounds: 0
         });
 
@@ -333,16 +398,17 @@ function buildTaskPlan(request = {}, options = {}) {
             nodes.push({
                 id: nodeId,
                 title: truncateText(item, 72) || `执行 ${executionNodeIds.length}`,
-                kind: 'codex',
-                prompt: buildCodexNodePrompt('work', {
+                kind: 'openai-chat',
+                prompt: buildOpenAiChatNodePrompt('work', {
                     title,
                     target,
                     item,
+                    cwd,
                     allowWrite
                 }),
                 dependsOn: [analysisId],
                 write: allowWrite,
-                retryLimit: 0,
+                retryLimit: OPENAI_CHAT_TRANSIENT_RETRY_LIMIT,
                 autoFixRounds
             });
         }
@@ -351,15 +417,16 @@ function buildTaskPlan(request = {}, options = {}) {
         nodes.push({
             id: verifyId,
             title: '验证与总结',
-            kind: 'codex',
-            prompt: buildCodexNodePrompt('verify', {
+            kind: 'openai-chat',
+            prompt: buildOpenAiChatNodePrompt('verify', {
                 title,
                 target,
+                cwd,
                 allowWrite: false
             }),
             dependsOn: executionNodeIds.slice(),
             write: false,
-            retryLimit: 0,
+            retryLimit: OPENAI_CHAT_TRANSIENT_RETRY_LIMIT,
             autoFixRounds: 0
         });
     }
@@ -371,16 +438,17 @@ function buildTaskPlan(request = {}, options = {}) {
             nodes.push({
                 id: nodeId,
                 title: truncateText(followUp, 72) || `Follow-up ${nodes.length + 1}`,
-                kind: 'codex',
-                prompt: buildCodexNodePrompt('follow-up', {
+                kind: 'openai-chat',
+                prompt: buildOpenAiChatNodePrompt('follow-up', {
                     title,
                     target,
+                    cwd,
                     allowWrite,
                     followUp
                 }),
                 dependsOn: followUpDependsOn,
                 write: allowWrite,
-                retryLimit: 0,
+                retryLimit: OPENAI_CHAT_TRANSIENT_RETRY_LIMIT,
                 autoFixRounds
             });
             followUpDependsOn = [nodeId];
@@ -389,6 +457,7 @@ function buildTaskPlan(request = {}, options = {}) {
 
     const plan = {
         id: normalizeId(request.id, ''),
+        threadId,
         title,
         target,
         notes,
@@ -417,7 +486,7 @@ function validateTaskPlan(plan, options = {}) {
     }
 
     const workflowMap = normalizeWorkflowCatalog(options.workflowCatalog || []);
-    const engine = normalizeId(plan.engine, 'codex') === 'workflow' ? 'workflow' : 'codex';
+    const engine = normalizeTaskEngine(plan.engine);
     const workflowIds = uniqueStringList(plan.workflowIds || []).map((id) => normalizeId(id, '')).filter(Boolean);
     const nodes = Array.isArray(plan.nodes) ? plan.nodes : [];
     if (engine === 'workflow' && workflowIds.length === 0) {
@@ -445,8 +514,8 @@ function validateTaskPlan(plan, options = {}) {
             continue;
         }
         nodeIds.add(id);
-        const kind = normalizeId(node.kind, '');
-        if (kind !== 'workflow' && kind !== 'codex') {
+        const kind = normalizeTaskNodeKind(node.kind);
+        if (kind !== 'workflow' && kind !== 'openai-chat') {
             issues.push({ code: 'task-node-kind-invalid', message: `task node ${id} has unsupported kind: ${node.kind || ''}` });
         }
         if (kind === 'workflow') {
@@ -457,7 +526,7 @@ function validateTaskPlan(plan, options = {}) {
                 issues.push({ code: 'task-node-workflow-unknown', message: `task node ${id} references unknown workflow: ${workflowId}` });
             }
         }
-        if (kind === 'codex' && !normalizeText(node.prompt, 12000)) {
+        if (kind === 'openai-chat' && !normalizeText(node.prompt, 12000)) {
             issues.push({ code: 'task-node-prompt-required', message: `task node ${id} missing prompt` });
         }
     }
@@ -492,7 +561,7 @@ function createNodeRunRecord(node, dependencyNodeIds = []) {
     return {
         id: normalizeId(node && node.id, ''),
         title: normalizeText(node && node.title, 160),
-        kind: normalizeId(node && node.kind, ''),
+        kind: normalizeTaskNodeKind(node && node.kind),
         workflowId: normalizeId(node && node.workflowId, ''),
         dependsOn: normalizeDependencyIds(node && node.dependsOn),
         dependencyNodeIds: uniqueStringList(dependencyNodeIds),

package/lib/task-workspace-chat.js

@@ -0,0 +1,292 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const TEXT_FILE_EXTENSIONS = new Set(['.html', '.htm', '.css', '.js', '.mjs', '.json', '.md', '.txt', '.svg', '.ts', '.tsx', '.jsx', '.yml', '.yaml']);
+const MAX_FILE_BYTES = 512 * 1024;
+const MAX_CONTEXT_FILE_BYTES = 16 * 1024;
+const MAX_CONTEXT_TOTAL_BYTES = 64 * 1024;
+const MAX_HISTORY_MESSAGES = 20;
+const SENSITIVE_CONTEXT_NAME_RE = /(^|[._\-/])(credential|credentials|secret|secrets|token|tokens|apikey|api-key|api_key|password|passwd|private-key|private_key|\.env)([._\-/]|$)/i;
+
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function sanitizeThreadId(value) {
+    const text = typeof value === 'string' ? value.trim() : '';
+    if (!text) return '';
+    return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(text) ? text : '';
+}
+
+function normalizeWorkspacePath(rawPath, cwd) {
+    const baseDir = path.resolve(typeof cwd === 'string' && cwd.trim() ? cwd.trim() : process.cwd());
+    const text = typeof rawPath === 'string' ? rawPath.trim().replace(/^['"]|['"]$/g, '') : '';
+    if (!text || text.length > 240) {
+        return { error: 'workspace file path is empty or too long' };
+    }
+    if (path.isAbsolute(text) || text.includes('\\')) {
+        return { error: `workspace file path must be a safe relative path: ${text}` };
+    }
+    const normalized = path.normalize(text);
+    if (!normalized || normalized === '.' || normalized.startsWith('..') || normalized.split(path.sep).includes('..')) {
+        return { error: `workspace file path escapes cwd: ${text}` };
+    }
+    const ext = path.extname(normalized).toLowerCase();
+    if (!TEXT_FILE_EXTENSIONS.has(ext)) {
+        return { error: `workspace file extension is not allowed: ${ext || '(none)'}` };
+    }
+    const targetPath = path.resolve(baseDir, normalized);
+    const relative = path.relative(baseDir, targetPath);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+        return { error: `workspace file path escapes cwd: ${text}` };
+    }
+    return { path: targetPath, relativePath: normalized, baseDir };
+}
+
+function validateParentPath(targetPath, baseDir) {
+    const resolvedBase = fs.realpathSync.native(baseDir);
+    let current = path.dirname(targetPath);
+    const pending = [];
+    while (true) {
+        if (current === resolvedBase) return { ok: true };
+        if (current === path.dirname(current)) return { ok: false, error: 'workspace parent escapes cwd' };
+        if (fs.existsSync(current)) {
+            const stats = fs.lstatSync(current);
+            if (stats.isSymbolicLink()) return { ok: false, error: `workspace parent is a symlink: ${path.relative(baseDir, current) || current}` };
+            const resolvedCurrent = fs.realpathSync.native(current);
+            const relative = path.relative(resolvedBase, resolvedCurrent);
+            if (relative.startsWith('..') || path.isAbsolute(relative)) return { ok: false, error: 'workspace parent resolves outside cwd' };
+            for (const child of pending) {
+                const childRelative = path.relative(resolvedBase, child);
+                if (childRelative.startsWith('..') || path.isAbsolute(childRelative)) return { ok: false, error: 'workspace parent escapes cwd' };
+            }
+            return { ok: true };
+        }
+        pending.push(current);
+        current = path.dirname(current);
+    }
+}
+
+function parseAttributes(info) {
+    const attrs = {};
+    const text = typeof info === 'string' ? info : '';
+    const attrRe = /([A-Za-z_][A-Za-z0-9_-]*)\s*=\s*("([^"]*)"|'([^']*)'|([^\s]+))/g;
+    let match;
+    while ((match = attrRe.exec(text)) !== null) {
+        attrs[match[1]] = match[3] || match[4] || match[5] || '';
+    }
+    return attrs;
+}
+
+function parseWorkspaceFileOperations(text) {
+    const content = typeof text === 'string' ? text : '';
+    const operations = [];
+    const fenceRe = /```([^\n`]*)\n([\s\S]*?)```/g;
+    let match;
+    while ((match = fenceRe.exec(content)) !== null) {
+        const info = String(match[1] || '').trim();
+        if (!/^codexmate-file\b/i.test(info)) continue;
+        const attrs = parseAttributes(info);
+        const action = String(attrs.action || attrs.op || 'write').trim().toLowerCase();
+        const filePath = String(attrs.path || attrs.file || attrs.filename || '').trim();
+        operations.push({ action: action === 'update' ? 'write' : action, path: filePath, content: String(match[2] || '') });
+    }
+
+    const deleteRe = /^\s*CODEXMATE_(?:DELETE|REMOVE)_FILE\s*:\s*(.+?)\s*$/gmi;
+    while ((match = deleteRe.exec(content)) !== null) {
+        operations.push({ action: 'delete', path: String(match[1] || '').trim(), content: '' });
+    }
+    return operations;
+}
+
+function isSensitiveWorkspaceContextFile(relativePath) {
+    const normalized = String(relativePath || '').replace(/\\+/g, '/').toLowerCase();
+    return SENSITIVE_CONTEXT_NAME_RE.test(normalized);
+}
+
+function isWorkspaceFileMentioned(relativePath, promptText) {
+    const normalizedPath = String(relativePath || '').toLowerCase();
+    const baseName = path.basename(normalizedPath);
+    return !!normalizedPath && (promptText.includes(normalizedPath) || (!!baseName && promptText.includes(baseName)));
+}
+
+function applyWorkspaceFileOperations(text, cwd, options = {}) {
+    const allowWrite = options.allowWrite === true;
+    const operations = parseWorkspaceFileOperations(text);
+    const files = [];
+    const warnings = [];
+    if (!allowWrite && operations.length > 0) {
+        return { files, warnings: ['workspace file operations skipped because allowWrite is false'] };
+    }
+    for (const operation of operations) {
+        const action = operation.action === 'delete' ? 'delete' : 'write';
+        const normalized = normalizeWorkspacePath(operation.path, cwd);
+        if (normalized.error) {
+            warnings.push(normalized.error);
+            continue;
+        }
+        try {
+            if (action === 'delete') {
+                if (!fs.existsSync(normalized.path)) {
+                    files.push({ path: normalized.path, relativePath: normalized.relativePath, bytes: 0, operation: 'delete', existed: false });
+                    continue;
+                }
+                const stats = fs.lstatSync(normalized.path);
+                if (stats.isSymbolicLink()) {
+                    warnings.push(`workspace target is a symlink: ${normalized.relativePath}`);
+                    continue;
+                }
+                if (!stats.isFile()) {
+                    warnings.push(`workspace target is not a file: ${normalized.relativePath}`);
+                    continue;
+                }
+                fs.unlinkSync(normalized.path);
+                files.push({ path: normalized.path, relativePath: normalized.relativePath, bytes: 0, operation: 'delete', existed: true });
+                continue;
+            }
+
+            const body = String(operation.content || '');
+            const bytes = Buffer.byteLength(body, 'utf-8');
+            if (bytes > MAX_FILE_BYTES) {
+                warnings.push(`workspace artifact too large and skipped: ${normalized.relativePath}`);
+                continue;
+            }
+            const parentValidation = validateParentPath(normalized.path, normalized.baseDir);
+            if (!parentValidation.ok) {
+                warnings.push(parentValidation.error || `workspace parent is unsafe: ${normalized.relativePath}`);
+                continue;
+            }
+            ensureDir(path.dirname(normalized.path));
+            try {
+                if (fs.lstatSync(normalized.path).isSymbolicLink()) {
+                    warnings.push(`workspace target is a symlink: ${normalized.relativePath}`);
+                    continue;
+                }
+            } catch (error) {
+                if (!error || error.code !== 'ENOENT') throw error;
+            }
+            fs.writeFileSync(normalized.path, body, { encoding: 'utf-8', mode: 0o600 });
+            files.push({ path: normalized.path, relativePath: normalized.relativePath, bytes, operation: 'write' });
+        } catch (error) {
+            warnings.push(`workspace operation failed for ${normalized.relativePath}: ${error && error.message ? error.message : String(error)}`);
+        }
+    }
+    return { files, warnings };
+}
+
+function walkWorkspace(cwd, options = {}) {
+    const baseDir = path.resolve(typeof cwd === 'string' && cwd.trim() ? cwd.trim() : process.cwd());
+    const maxFiles = Number.isFinite(options.maxFiles) ? options.maxFiles : 120;
+    const files = [];
+    const skipNames = new Set(['.git', 'node_modules', '.codexmate', '.DS_Store']);
+    function walk(dir) {
+        if (files.length >= maxFiles) return;
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch (_) {
+            return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (files.length >= maxFiles) break;
+            if (skipNames.has(entry.name)) continue;
+            const fullPath = path.join(dir, entry.name);
+            let stats;
+            try {
+                stats = fs.lstatSync(fullPath);
+            } catch (_) {
+                continue;
+            }
+            if (stats.isSymbolicLink()) continue;
+            const relativePath = path.relative(baseDir, fullPath);
+            if (stats.isDirectory()) {
+                walk(fullPath);
+            } else if (stats.isFile()) {
+                files.push({ path: fullPath, relativePath, bytes: stats.size, ext: path.extname(relativePath).toLowerCase() });
+            }
+        }
+    }
+    if (fs.existsSync(baseDir)) walk(baseDir);
+    return files;
+}
+
+function buildWorkspaceChatContext(cwd, prompt = '', historyMessages = []) {
+    const files = walkWorkspace(cwd);
+    const promptText = [prompt, ...historyMessages.map((item) => item && item.content ? item.content : '')].join('\n').toLowerCase();
+    const treeLines = files.map((file) => `- ${file.relativePath} (${file.bytes} bytes)`);
+    const contentBlocks = [];
+    let total = 0;
+    for (const file of files) {
+        if (!TEXT_FILE_EXTENSIONS.has(file.ext)) continue;
+        if (file.bytes > MAX_CONTEXT_FILE_BYTES) continue;
+        const mentioned = isWorkspaceFileMentioned(file.relativePath, promptText);
+        if (!mentioned) continue;
+        if (isSensitiveWorkspaceContextFile(file.relativePath)) continue;
+        if (total + file.bytes > MAX_CONTEXT_TOTAL_BYTES) break;
+        try {
+            const body = fs.readFileSync(file.path, 'utf-8');
+            total += Buffer.byteLength(body, 'utf-8');
+            contentBlocks.push(`### ${file.relativePath}\n\`\`\`\n${body}\n\`\`\``);
+        } catch (_) {}
+    }
+    return [
+        '当前工作区文件列表:',
+        treeLines.length ? treeLines.join('\n') : '(empty workspace)',
+        contentBlocks.length ? '\n当前工作区可读文本文件内容快照:\n' + contentBlocks.join('\n\n') : '\n当前没有可注入的文本文件内容快照。'
+    ].join('\n');
+}
+
+function getThreadFile(storeDir, threadId) {
+    const safe = sanitizeThreadId(threadId);
+    if (!safe) return '';
+    return path.join(storeDir, `${safe}.json`);
+}
+
+function loadWorkspaceChatThread(storeDir, threadId) {
+    const file = getThreadFile(storeDir, threadId);
+    if (!file || !fs.existsSync(file)) return { threadId: sanitizeThreadId(threadId), messages: [] };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        const messages = Array.isArray(parsed.messages) ? parsed.messages.filter((item) => item && (item.role === 'user' || item.role === 'assistant') && typeof item.content === 'string') : [];
+        return { ...parsed, threadId: sanitizeThreadId(parsed.threadId || threadId), messages: messages.slice(-MAX_HISTORY_MESSAGES) };
+    } catch (_) {
+        return { threadId: sanitizeThreadId(threadId), messages: [] };
+    }
+}
+
+function appendWorkspaceChatThread(storeDir, threadId, messages, metadata = {}) {
+    const safe = sanitizeThreadId(threadId);
+    if (!safe) return { ok: false, error: 'invalid thread id' };
+    ensureDir(storeDir);
+    const existing = loadWorkspaceChatThread(storeDir, safe);
+    const now = new Date().toISOString();
+    const nextMessages = existing.messages.concat((Array.isArray(messages) ? messages : []).map((item) => ({
+        role: item.role === 'assistant' ? 'assistant' : 'user',
+        content: String(item.content || ''),
+        at: item.at || now
+    }))).slice(-MAX_HISTORY_MESSAGES);
+    const payload = {
+        threadId: safe,
+        cwd: metadata.cwd || existing.cwd || '',
+        updatedAt: now,
+        messages: nextMessages
+    };
+    const file = getThreadFile(storeDir, safe);
+    fs.writeFileSync(file, JSON.stringify(payload, null, 2), { encoding: 'utf-8', mode: 0o600 });
+    return { ok: true, file, messageCount: nextMessages.length };
+}
+
+module.exports = {
+    TEXT_FILE_EXTENSIONS,
+    sanitizeThreadId,
+    normalizeWorkspacePath,
+    parseWorkspaceFileOperations,
+    applyWorkspaceFileOperations,
+    walkWorkspace,
+    buildWorkspaceChatContext,
+    loadWorkspaceChatThread,
+    appendWorkspaceChatThread
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexmate",
-  "version": "0.0.55",
+  "version": "0.0.57",
   "description": "Codex/Claude Code/OpenClaw 配置、会话与任务编排 CLI + Web 工具",
   "main": "cli.js",
   "bin": {
@@ -72,7 +72,7 @@
   "author": "ymkiux",
   "license": "Apache-2.0",
   "devDependencies": {
-    "@vue/compiler-dom": "^3.5.30",
+    "@vue/compiler-dom": "^3.5.34",
     "opencc-js": "^1.3.1",
     "vitepress": "^1.6.4"
   }