evolcore 0.0.35 → 0.0.37

package/dist/core/command/diag-service.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { isValidAid } from '../../aun/aid/validation.js';
 import { atomicReadJson, atomicWriteJson } from '../../utils/atomic-write.js';
+import { isMainSession } from '../thread/topic-id.js';
 import { remoteAccessService } from '../auth/remote-access-store.js';
 import { KeyedFairMutex } from '../handoff/mutex.js';
 export const DIAGNOSTIC_AGENT_AID = 'diag.agentid.cn';
@@ -291,7 +292,7 @@ export class DiagnosticSessionRouter {
         return diagnosticLocks.forKey(diagnosticLedgerPath(chatDir)).runExclusive(async () => {
             const all = await this.sessions.listSessions(channel, message.channelId, { archiveFilter: 'all' });
             const ledger = readDiagnosticLedger(chatDir);
-            const find = (caseId) => all.find(s => !s.threadId && s.selfAID === selfAid
+            const find = (caseId) => all.find(s => isMainSession(s) && s.selfAID === selfAid
                 && s.metadata?.diagnostic?.caseId === caseId && s.metadata.diagnostic.controlAid === event.controlAid);
             let record = ledger.cases[event.caseId];
             if (record && record.ownerAid !== event.ownerAid)
@@ -300,7 +301,7 @@ export class DiagnosticSessionRouter {
                 let session = find(event.caseId);
                 if (!session) {
                     const legacy = this.sessions.getActiveSessionSync(channel, message.channelId, channelType, selfAid);
-                    if (legacy && !legacy.threadId && !legacy.metadata?.diagnostic) {
+                    if (legacy && isMainSession(legacy) && !legacy.metadata?.diagnostic) {
                         await this.sessions.patchSessionMetadata(legacy.id, { diagnosticStatus: 'cancelled' });
                         session = legacy;
                     }
@@ -341,7 +342,7 @@ export class DiagnosticSessionRouter {
             if (ledger.activeCaseId !== event.caseId)
                 return { notice: '该诊断已被新诊断替代。' };
             const oldActive = this.sessions.getActiveSessionSync(channel, message.channelId, channelType, selfAid);
-            if (!record.cleanupComplete && oldActive && !oldActive.threadId && !oldActive.metadata?.diagnostic) {
+            if (!record.cleanupComplete && oldActive && isMainSession(oldActive) && !oldActive.metadata?.diagnostic) {
                 // Migration from the historical shared Control conversation. Owner
                 // conversations and sessions belonging to other hosts are untouched.
                 await this.sessions.patchSessionMetadata(oldActive.id, { diagnosticStatus: 'cancelled' });
@@ -349,7 +350,7 @@ export class DiagnosticSessionRouter {
             }
             // Retry interruption too after an interrupted creation attempt.
             for (const previous of record.cleanupComplete ? [] : all) {
-                if (!previous.threadId && previous.metadata?.diagnostic?.controlAid === event.controlAid
+                if (isMainSession(previous) && previous.metadata?.diagnostic?.controlAid === event.controlAid
                     && previous.metadata.diagnostic.caseId !== event.caseId)
                     await this.stopSession(previous.id);
             }

package/dist/core/command/file-search.js

@@ -0,0 +1,368 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+export const FILE_SEARCH_MAX_CONTENT_BYTES = 2 * 1024 * 1024;
+export const FILE_SEARCH_MAX_RESPONSE_BYTES = 64 * 1024;
+const DEFAULT_LIMIT = 100;
+const MAX_LIMIT = 500;
+const MAX_MATCHES = 3;
+const MAX_SNIPPET_LENGTH = 200;
+const EXCLUDED_DIRECTORIES = new Set(['.git', 'node_modules']);
+export class FileSearchError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'FileSearchError';
+    }
+}
+export function parseFileSearchArgs(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new FileSearchError('INVALID_ARGUMENT', 'File search requires args');
+    }
+    const args = value;
+    if (Object.hasOwn(args, 'rootId')) {
+        throw new FileSearchError('INVALID_ARGUMENT', 'File search only supports the current project, not rootId');
+    }
+    if (args.path !== undefined && (typeof args.path !== 'string' || !args.path.trim()
+        || args.path.length > 4096 || args.path.includes('\0'))) {
+        throw new FileSearchError('INVALID_ARGUMENT', 'File search path must be a non-empty path');
+    }
+    for (const key of ['filename', 'content']) {
+        const query = args[key];
+        if (query !== undefined && (typeof query !== 'string' || !query.length || query.length > 1024
+            || query.includes('\0'))) {
+            throw new FileSearchError('INVALID_ARGUMENT', `File search ${key} must contain 1–1024 characters`);
+        }
+    }
+    for (const key of ['recursive', 'caseSensitive']) {
+        if (args[key] !== undefined && typeof args[key] !== 'boolean') {
+            throw new FileSearchError('INVALID_ARGUMENT', `File search ${key} must be a boolean`);
+        }
+    }
+    if (args.limit !== undefined && (!Number.isInteger(args.limit) || Number(args.limit) < 1
+        || Number(args.limit) > MAX_LIMIT)) {
+        throw new FileSearchError('INVALID_ARGUMENT', `File search limit must be an integer from 1 to ${MAX_LIMIT}`);
+    }
+    if (args.extensions !== undefined && (!Array.isArray(args.extensions) || args.extensions.length > 64)) {
+        throw new FileSearchError('INVALID_ARGUMENT', 'File search extensions must be an array of at most 64 extensions');
+    }
+    const extensions = new Set();
+    for (const extension of (args.extensions ?? [])) {
+        if (typeof extension !== 'string' || !/^\.?[^.\s\\/*?\0]{1,64}$/.test(extension)) {
+            throw new FileSearchError('INVALID_ARGUMENT', 'File search extensions must be literal suffixes such as ts or .json');
+        }
+        extensions.add(`.${extension.replace(/^\./, '').toLowerCase()}`);
+    }
+    if (args.filename === undefined && args.content === undefined && !extensions.size) {
+        throw new FileSearchError('INVALID_ARGUMENT', 'File search requires filename, content or extensions');
+    }
+    return {
+        path: args.path ?? '.',
+        recursive: args.recursive ?? true,
+        filename: args.filename,
+        content: args.content,
+        extensions: [...extensions],
+        caseSensitive: args.caseSensitive ?? false,
+        limit: args.limit ?? DEFAULT_LIMIT,
+    };
+}
+function isInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`));
+}
+function relativePath(root, candidate) {
+    return path.relative(root, candidate).split(path.sep).join('/') || '.';
+}
+function fileExtension(filename) {
+    const extension = path.extname(filename).toLowerCase();
+    if (extension)
+        return extension;
+    return filename.startsWith('.') && filename.indexOf('.', 1) < 0 ? filename.toLowerCase() : '';
+}
+async function searchDirectory(projectPath, input) {
+    if (input.split(/[\\/]/).includes('..') || (!path.isAbsolute(input) && path.win32.isAbsolute(input))) {
+        throw new FileSearchError('NO_PERMISSION', 'File search does not allow path traversal');
+    }
+    const logicalRoot = path.resolve(projectPath);
+    const root = await fs.promises.realpath(logicalRoot);
+    const candidate = path.resolve(logicalRoot, input);
+    const base = isInside(logicalRoot, candidate) ? logicalRoot : root;
+    if (!isInside(base, candidate)) {
+        throw new FileSearchError('NO_PERMISSION', 'File search must stay inside the current project');
+    }
+    let current = base;
+    for (const segment of path.relative(base, candidate).split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        if ((await fs.promises.lstat(current)).isSymbolicLink()) {
+            throw new FileSearchError('NO_PERMISSION', 'File search does not follow symbolic links');
+        }
+    }
+    const start = await fs.promises.realpath(candidate);
+    if (!isInside(root, start)) {
+        throw new FileSearchError('NO_PERMISSION', 'File search must stay inside the current project');
+    }
+    if (!(await fs.promises.stat(start)).isDirectory()) {
+        throw new FileSearchError('NOT_A_DIRECTORY', 'File search path must be a directory');
+    }
+    return { root, start };
+}
+function contentMatches(text, query, caseSensitive) {
+    const lines = text.split(/\r\n|\r|\n/);
+    const comparedLines = caseSensitive ? lines : lines.map(line => line.toLowerCase());
+    const haystack = comparedLines.join('\n');
+    const normalizedQuery = query.replace(/\r\n|\r/g, '\n');
+    const needle = caseSensitive ? normalizedQuery : normalizedQuery.toLowerCase();
+    const matches = [];
+    let position = 0;
+    let lineIndex = 0;
+    let lineStart = 0;
+    let lineEnd = comparedLines[0].length;
+    while (matches.length < MAX_MATCHES) {
+        const found = haystack.indexOf(needle, position);
+        if (found < 0)
+            break;
+        while (found > lineEnd && lineIndex < lines.length - 1) {
+            lineStart = lineEnd + 1;
+            lineIndex++;
+            lineEnd = lineStart + comparedLines[lineIndex].length;
+        }
+        let column = found - lineStart;
+        if (!caseSensitive) {
+            let comparedColumn = 0;
+            let originalColumn = 0;
+            for (const character of lines[lineIndex]) {
+                if (comparedColumn >= column)
+                    break;
+                comparedColumn += character.toLowerCase().length;
+                originalColumn += character.length;
+            }
+            column = originalColumn;
+        }
+        const snippetStart = Math.max(0, column - Math.floor(MAX_SNIPPET_LENGTH / 3));
+        matches.push({
+            line: lineIndex + 1,
+            text: lines[lineIndex]
+                .slice(snippetStart, snippetStart + MAX_SNIPPET_LENGTH)
+                .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '�'),
+        });
+        position = lineEnd + 1;
+        if (position > haystack.length)
+            break;
+    }
+    return matches;
+}
+async function readContent(filePath, expected, signal) {
+    const handle = await fs.promises.open(filePath, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+    try {
+        const opened = await handle.stat();
+        if (!opened.isFile() || opened.dev !== expected.dev || opened.ino !== expected.ino) {
+            return { skipped: 'unreadable' };
+        }
+        if (opened.size > FILE_SEARCH_MAX_CONTENT_BYTES)
+            return { skipped: 'tooLarge' };
+        const decoder = new TextDecoder('utf-8', { fatal: true });
+        const chunks = [];
+        let bytes = 0;
+        let controlBytes = 0;
+        const stream = handle.createReadStream({
+            autoClose: false, highWaterMark: 64 * 1024, end: FILE_SEARCH_MAX_CONTENT_BYTES, signal,
+        });
+        try {
+            for await (const chunk of stream) {
+                const buffer = chunk;
+                bytes += buffer.length;
+                if (bytes > FILE_SEARCH_MAX_CONTENT_BYTES)
+                    return { skipped: 'tooLarge' };
+                if (buffer.includes(0))
+                    return { skipped: 'binary' };
+                for (const byte of buffer) {
+                    if ((byte < 32 && byte !== 9 && byte !== 10 && byte !== 12 && byte !== 13) || byte === 127)
+                        controlBytes++;
+                }
+                try {
+                    chunks.push(decoder.decode(buffer, { stream: true }));
+                }
+                catch {
+                    return { skipped: 'unsupportedEncoding' };
+                }
+            }
+            try {
+                chunks.push(decoder.decode());
+            }
+            catch {
+                return { skipped: 'unsupportedEncoding' };
+            }
+            if (bytes > 0 && controlBytes / bytes > 0.1)
+                return { skipped: 'binary' };
+            const stat = await handle.stat();
+            if (stat.size > FILE_SEARCH_MAX_CONTENT_BYTES)
+                return { skipped: 'tooLarge' };
+            return { text: chunks.join(''), stat };
+        }
+        finally {
+            stream.destroy();
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function searchProjectFiles(projectPath, value, options = {}) {
+    const args = parseFileSearchArgs(value);
+    if (!projectPath)
+        throw new FileSearchError('NO_PROJECT', 'Unable to resolve the current Agent projectPath');
+    const { timeoutMs = 5000, maxEntries = 10000, maxResponseBytes = FILE_SEARCH_MAX_RESPONSE_BYTES } = options;
+    const controller = new AbortController();
+    const deadline = performance.now() + timeoutMs;
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    timer.unref();
+    try {
+        const { root, start } = await searchDirectory(projectPath, args.path);
+        const result = {
+            path: relativePath(root, start), entries: [], count: 0, scannedFiles: 0,
+            truncated: false, truncatedReason: null,
+            skipped: { binary: 0, unsupportedEncoding: 0, tooLarge: 0, unreadable: 0, symlink: 0 },
+        };
+        const stop = (reason) => {
+            result.truncated = true;
+            result.truncatedReason = reason;
+        };
+        const outOfTime = () => {
+            if (controller.signal.aborted || performance.now() >= deadline) {
+                stop('time_limit');
+                controller.abort();
+                return true;
+            }
+            return false;
+        };
+        let visited = 0;
+        let responseBytes = Buffer.byteLength(JSON.stringify(result)) + 512;
+        const directories = [start];
+        const filename = args.caseSensitive ? args.filename : args.filename?.toLowerCase();
+        while (directories.length && !result.truncated && !outOfTime()) {
+            const directory = directories.pop();
+            try {
+                if (await fs.promises.realpath(directory) !== directory) {
+                    result.skipped.symlink++;
+                    continue;
+                }
+                const entries = await fs.promises.opendir(directory);
+                for await (const entry of entries) {
+                    if (outOfTime())
+                        break;
+                    if (visited++ >= maxEntries) {
+                        stop('file_limit');
+                        break;
+                    }
+                    const fullPath = path.join(directory, entry.name);
+                    try {
+                        const stat = await fs.promises.lstat(fullPath);
+                        if (options.canAccessFile
+                            && !await options.canAccessFile(relativePath(root, fullPath), fullPath, stat.isDirectory())) {
+                            continue;
+                        }
+                        if (outOfTime())
+                            break;
+                        if (stat.isSymbolicLink()) {
+                            result.skipped.symlink++;
+                            continue;
+                        }
+                        if (stat.isDirectory()) {
+                            if (args.recursive && !EXCLUDED_DIRECTORIES.has(entry.name)) {
+                                const realDirectory = await fs.promises.realpath(fullPath);
+                                if (realDirectory !== fullPath || !isInside(root, realDirectory)) {
+                                    result.skipped.symlink++;
+                                    continue;
+                                }
+                                directories.push(realDirectory);
+                            }
+                            continue;
+                        }
+                        if (!stat.isFile())
+                            continue;
+                        result.scannedFiles++;
+                        const comparedName = args.caseSensitive ? entry.name : entry.name.toLowerCase();
+                        if (filename !== undefined && !comparedName.includes(filename))
+                            continue;
+                        if (args.extensions.length && !args.extensions.includes(fileExtension(entry.name)))
+                            continue;
+                        if (await fs.promises.realpath(fullPath) !== fullPath || !isInside(root, fullPath)) {
+                            result.skipped.symlink++;
+                            continue;
+                        }
+                        let fileStat = stat;
+                        let matches = [];
+                        if (args.content !== undefined) {
+                            if (stat.size > FILE_SEARCH_MAX_CONTENT_BYTES) {
+                                result.skipped.tooLarge++;
+                                continue;
+                            }
+                            const content = await readContent(fullPath, stat, controller.signal);
+                            if (outOfTime())
+                                break;
+                            if ('skipped' in content) {
+                                result.skipped[content.skipped]++;
+                                continue;
+                            }
+                            matches = contentMatches(content.text, args.content, args.caseSensitive);
+                            if (outOfTime())
+                                break;
+                            if (!matches.length)
+                                continue;
+                            fileStat = content.stat;
+                        }
+                        if (await fs.promises.realpath(fullPath) !== fullPath) {
+                            result.skipped.symlink++;
+                            continue;
+                        }
+                        if (outOfTime())
+                            break;
+                        const match = {
+                            path: relativePath(root, fullPath), name: entry.name,
+                            size: fileStat.size, mtime: fileStat.mtimeMs, matches,
+                        };
+                        const entryBytes = Buffer.byteLength(JSON.stringify(match)) + 1;
+                        if (responseBytes + entryBytes > maxResponseBytes) {
+                            stop('response_limit');
+                            break;
+                        }
+                        result.entries.push(match);
+                        result.count++;
+                        responseBytes += entryBytes;
+                        if (result.count >= args.limit) {
+                            stop('result_limit');
+                            break;
+                        }
+                    }
+                    catch {
+                        if (outOfTime())
+                            break;
+                        result.skipped.unreadable++;
+                    }
+                }
+            }
+            catch {
+                if (outOfTime())
+                    break;
+                if (directory === start)
+                    throw new FileSearchError('NO_PERMISSION', 'Unable to read the search directory');
+                result.skipped.unreadable++;
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        if (error instanceof FileSearchError)
+            throw error;
+        const code = error.code;
+        if (code === 'ENOENT')
+            throw new FileSearchError('NOT_FOUND', 'File search directory does not exist');
+        if (code === 'ENOTDIR')
+            throw new FileSearchError('NOT_A_DIRECTORY', 'File search path must be a directory');
+        throw new FileSearchError(code === 'EACCES' || code === 'EPERM' ? 'NO_PERMISSION' : 'EXEC_FAILED', 'Unable to search the current project');
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/core/command/menu-catalog.js

@@ -102,7 +102,8 @@ const ENTRIES = [
     { id: 'system.logs', type: 'list', contexts: ['process'], name: 'system', label: 'Daemon 日志', section: 'process', order: 12, query: { cmd: '/system', args: { view: 'logs' }, operation: 'system.status', scope: 'process' }, options: { cmd: '/system', args: { option: 'logs' }, operation: 'system.status', scope: 'process', mode: 'dynamic' }, control: 'list' },
     { id: 'config.rawFile', type: 'list', contexts: ['process'], name: 'config', label: '原始配置文件', section: 'process', order: 13, query: { cmd: '/config', args: { view: 'rawFile' }, operation: 'config.read', scope: 'process' }, options: { cmd: '/config', args: { option: 'rawFile' }, operation: 'config.read', scope: 'process', mode: 'dynamic' }, control: 'list' },
     { id: 'system.restart', type: 'action', contexts: ['process'], name: 'system', label: '重启服务', section: 'process', order: 20, action: { cmd: '/system', action: 'restart', operation: 'system.restart', scope: 'process' } },
-    { id: 'system.upgrade', type: 'action', contexts: ['process'], name: 'system', label: '升级服务', section: 'process', order: 30, action: { cmd: '/system', action: 'upgrade', operation: 'system.upgrade', scope: 'process' } },
+    { id: 'system.upgrade', type: 'action', contexts: ['process'], name: 'system', label: '检查更新', section: 'process', order: 30, action: { cmd: '/system', action: 'upgrade', args: { mode: 'check' }, operation: 'system.upgrade', scope: 'process' } },
+    { id: 'system.upgrade.update', type: 'action', contexts: ['process'], name: 'system', label: '执行更新', section: 'process', order: 31, action: { cmd: '/system', action: 'upgrade', args: { mode: 'update' }, operation: 'system.upgrade', scope: 'process' } },
     { id: 'system.paircode', type: 'action', contexts: ['process'], name: 'system', label: '获取配对码', section: 'process', order: 35, action: { cmd: '/system', action: 'paircode', operation: 'system.paircode', scope: 'process' } },
     { id: 'agent.list', type: 'list', contexts: ['process'], name: 'agent', label: 'Agent 列表', section: 'process', order: 40, options: { cmd: '/agent', args: { options: 'all' }, operation: 'agent.list', scope: 'control', mode: 'dynamic' }, control: 'list' },
     { id: 'agent.create', type: 'action', contexts: ['process'], name: 'agent', label: '创建 Agent', section: 'process', order: 50, action: { cmd: '/agent', action: 'create', operation: 'agent.create', scope: 'control' } },