evolcore 0.0.1 → 0.0.3

package/dist/utils/cross-platform.js

@@ -0,0 +1,297 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execFileSync, execFile, spawn, spawnSync } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs';
+const execFileAsync = promisify(execFile);
+export const isWindows = process.platform === 'win32';
+const ENCODE_PATH_MAX = 200;
+function encodePathHash(s) {
+    let h = 0;
+    for (let i = 0; i < s.length; i++)
+        h = (h << 5) - h + s.charCodeAt(i) | 0;
+    return Math.abs(h).toString(36);
+}
+/**
+ * Encode project path as directory name (Claude SDK convention).
+ * Mirrors the SDK's F0(L_(path)) logic:
+ *   1. path.resolve → realpath (if exists) → Unicode NFC
+ *   2. replace every non-alphanumeric character with '-'
+ *   3. truncate to 200 chars + hash suffix for long paths
+ * This must stay in sync with the SDK so evolcore can locate session files.
+ */
+export function encodePath(projectPath) {
+    const resolved = path.resolve(projectPath);
+    let real = resolved;
+    try {
+        real = fs.realpathSync(resolved);
+    }
+    catch { }
+    const nfc = real.normalize('NFC');
+    const encoded = nfc.replace(/[^a-zA-Z0-9]/g, '-');
+    if (encoded.length <= ENCODE_PATH_MAX)
+        return encoded;
+    return `${encoded.slice(0, ENCODE_PATH_MAX)}-${encodePathHash(nfc)}`;
+}
+/**
+ * Cross-platform process liveness check.
+ */
+export function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        // ESRCH = process not found; EPERM = exists but no permission
+        return e.code === 'EPERM';
+    }
+}
+/**
+ * Cross-platform process termination.
+ */
+export function killProcess(pid, force = false) {
+    if (isWindows && force) {
+        try {
+            spawnSync('taskkill', ['/PID', String(pid), '/F'], { windowsHide: true });
+        }
+        catch { }
+    }
+    else {
+        try {
+            process.kill(pid, force ? 'SIGKILL' : 'SIGTERM');
+        }
+        catch { }
+    }
+}
+/**
+ * Cross-platform process search by command line pattern.
+ * Returns list of matching PIDs.
+ */
+export function findProcesses(pattern) {
+    try {
+        if (isWindows) {
+            const result = spawnSync('wmic', ['process', 'where', `CommandLine like '%${pattern}%'`, 'get', 'ProcessId'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+            const output = result.stdout || '';
+            return output.split('\n')
+                .map(line => parseInt(line.trim(), 10))
+                .filter(pid => !isNaN(pid) && pid !== process.pid);
+        }
+        else {
+            const output = execFileSync('pgrep', ['-f', pattern], { encoding: 'utf-8' }).trim();
+            return output ? output.split('\n').map(Number).filter(pid => pid !== process.pid) : [];
+        }
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Cross-platform: find PIDs listening on a TCP port.
+ * Used to clean up stale/orphaned listeners (e.g. manually-spawned ecweb
+ * that never registered a pid file) before binding the port again.
+ */
+export function findProcessByPort(port) {
+    const pids = new Set();
+    try {
+        if (isWindows) {
+            const result = spawnSync('netstat', ['-ano', '-p', 'TCP'], { encoding: 'utf-8', windowsHide: true });
+            const output = result.stdout || '';
+            for (const line of output.split('\n')) {
+                // 形如:  TCP    0.0.0.0:42705   0.0.0.0:0   LISTENING   23004
+                if (!/LISTENING/i.test(line))
+                    continue;
+                const m = line.match(/:(\d+)\s+\S+\s+LISTENING\s+(\d+)/i);
+                if (m && Number(m[1]) === port) {
+                    const pid = Number(m[2]);
+                    if (pid && pid !== process.pid)
+                        pids.add(pid);
+                }
+            }
+        }
+        else {
+            const output = execFileSync('lsof', ['-ti', `tcp:${port}`, '-sTCP:LISTEN'], { encoding: 'utf-8' }).trim();
+            for (const line of output.split('\n')) {
+                const pid = parseInt(line.trim(), 10);
+                if (pid && pid !== process.pid)
+                    pids.add(pid);
+            }
+        }
+    }
+    catch { /* netstat/lsof missing or no match */ }
+    return [...pids];
+}
+export function getProcessInfo(pid) {
+    try {
+        if (isWindows) {
+            const result = spawnSync('wmic', ['process', 'where', `ProcessId=${pid}`, 'get', 'WorkingSetSize,CreationDate'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+            const output = result.stdout || '';
+            const lines = output.trim().split('\n').filter(l => l.trim());
+            if (lines.length >= 2) {
+                const parts = lines[1].trim().split(/\s+/);
+                const memKB = parts[1] ? Math.round(parseInt(parts[1], 10) / 1024) : undefined;
+                return { memory: memKB ? `${memKB}` : undefined };
+            }
+        }
+        else {
+            const etimes = execFileSync('ps', ['-p', String(pid), '-o', 'etimes='], { encoding: 'utf-8' }).trim();
+            const cpu = execFileSync('ps', ['-p', String(pid), '-o', '%cpu='], { encoding: 'utf-8' }).trim();
+            const mem = execFileSync('ps', ['-p', String(pid), '-o', 'rss='], { encoding: 'utf-8' }).trim();
+            const uptime = formatUptime(parseInt(etimes, 10));
+            return { uptime, cpu, memory: mem };
+        }
+    }
+    catch { }
+    return {};
+}
+function formatUptime(totalSeconds) {
+    if (isNaN(totalSeconds) || totalSeconds < 0)
+        return 'unknown';
+    const days = Math.floor(totalSeconds / 86400);
+    const hours = Math.floor((totalSeconds % 86400) / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days}d`);
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (parts.length === 0)
+        parts.push(`${seconds}s`);
+    return parts.join(' ');
+}
+/**
+ * Cross-platform command existence check.
+ */
+const _commandExistsCache = new Map();
+export function commandExists(cmd) {
+    const cached = _commandExistsCache.get(cmd);
+    if (cached !== undefined)
+        return cached;
+    let exists = false;
+    try {
+        if (isWindows) {
+            const r = spawnSync('where', [cmd], { encoding: 'utf-8', stdio: 'pipe', windowsHide: true });
+            exists = r.status === 0;
+        }
+        else {
+            execFileSync('which', [cmd], { encoding: 'utf-8', stdio: 'pipe' });
+            exists = true;
+        }
+    }
+    catch {
+        exists = false;
+    }
+    _commandExistsCache.set(cmd, exists);
+    return exists;
+}
+/**
+ * 解析命令的真实可执行文件绝对路径。
+ * Windows: `where` 会列出全部同名文件（npm 全局 bin 同时生成无后缀 sh 包装、.cmd、.ps1），
+ *   其中无后缀的那个是 Unix sh 脚本，Windows 无法直接 spawn（ENOENT）。
+ *   因此优先选 PATHEXT 可执行后缀（.cmd/.exe/.bat/.com），都没有才退回首行。
+ * 失败返回 null。不缓存——刚安装的命令需要重新探测。
+ */
+export function resolveCommandPath(cmd) {
+    try {
+        if (isWindows) {
+            const r = spawnSync('where', [cmd], { encoding: 'utf-8', stdio: 'pipe', windowsHide: true });
+            if (r.status !== 0 || !r.stdout)
+                return null;
+            const candidates = r.stdout.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+            if (candidates.length === 0)
+                return null;
+            const execExts = ['.cmd', '.exe', '.bat', '.com'];
+            const runnable = candidates.find(p => execExts.some(ext => p.toLowerCase().endsWith(ext)));
+            return runnable || candidates[0];
+        }
+        else {
+            const out = execFileSync('which', [cmd], { encoding: 'utf-8', stdio: 'pipe' }).trim();
+            return out || null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Cross-platform live log tailing (replaces tail -f).
+ * Returns an abort function.
+ */
+export function tailFile(filePath) {
+    if (!isWindows) {
+        // Unix: use tail -f (more efficient)
+        const child = spawn('tail', ['-f', filePath], { stdio: 'inherit' });
+        child.on('exit', (code) => process.exit(code || 0));
+        return { abort: () => child.kill() };
+    }
+    // Windows: Node.js-based implementation using stat polling
+    // (fs.watch / ReadDirectoryChangesW is unreliable for cross-process appends)
+    // Output last 20 lines of existing content
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const lastLines = lines.slice(-20);
+    process.stdout.write(lastLines.join('\n'));
+    let position = fs.statSync(filePath).size;
+    const listener = () => {
+        try {
+            const stat = fs.statSync(filePath);
+            if (stat.size < position) {
+                // File was truncated (log rotation) — reset and re-read from start
+                position = 0;
+            }
+            if (stat.size > position) {
+                const fd = fs.openSync(filePath, 'r');
+                const buffer = Buffer.alloc(stat.size - position);
+                fs.readSync(fd, buffer, 0, buffer.length, position);
+                fs.closeSync(fd);
+                process.stdout.write(buffer.toString('utf-8'));
+                position = stat.size;
+            }
+        }
+        catch {
+            // File may be briefly unavailable during rotation — ignore and retry next tick
+        }
+    };
+    fs.watchFile(filePath, { interval: 500, persistent: true }, listener);
+    return { abort: () => fs.unwatchFile(filePath, listener) };
+}
+/**
+ * Resolve file path from import.meta.url (cross-platform safe).
+ * Replaces unsafe `new URL('.', import.meta.url).pathname` usage.
+ */
+export function dirFromImportMeta(importMetaUrl) {
+    return path.dirname(fileURLToPath(importMetaUrl));
+}
+/**
+ * Check if current file is the main entry script (cross-platform safe).
+ * Replaces unsafe `import.meta.url === \`file://\${process.argv[1]}\`` check.
+ */
+export function isMainScript(importMetaUrl) {
+    const argv1 = process.argv[1];
+    if (!argv1)
+        return false;
+    try {
+        const selfPath = fileURLToPath(importMetaUrl);
+        const argvPath = fs.realpathSync(argv1);
+        return selfPath === argvPath || fs.realpathSync(selfPath) === argvPath;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Register graceful shutdown signal handlers (cross-platform safe).
+ */
+export function onShutdown(callback) {
+    process.on('SIGINT', callback);
+    // SIGTERM is not fully supported on Windows, but Node.js can still emit it
+    // in some scenarios (e.g., process managers), so register it anyway
+    process.on('SIGTERM', callback);
+    if (isWindows) {
+        // On Windows, also handle SIGHUP for graceful shutdown
+        // when the process is terminated via Task Manager or similar
+        process.on('SIGHUP', callback);
+    }
+}

package/dist/utils/ecweb-utils.js

@@ -0,0 +1,73 @@
+import fs from 'fs';
+import path from 'path';
+import { resolveGlobalPkg } from './npm-ops.js';
+import { isWindows as platformIsWindows, resolveCommandPath } from './cross-platform.js';
+import { WEB_CLI_BIN, WEB_PACKAGE_NAME } from '../product.js';
+function readEcwebPackageEntry(pkgJsonPath) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+        const bin = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.[WEB_CLI_BIN];
+        if (!bin)
+            return null;
+        const entry = path.resolve(path.dirname(pkgJsonPath), bin);
+        return fs.existsSync(entry) ? entry : null;
+    }
+    catch {
+        return null;
+    }
+}
+function packageJsonBesideNpmShim(commandPath, isWindows) {
+    if (!isWindows || !/\.(cmd|bat)$/i.test(commandPath))
+        return null;
+    const pkgJsonPath = path.join(path.dirname(commandPath), 'node_modules', WEB_PACKAGE_NAME, 'package.json');
+    return fs.existsSync(pkgJsonPath) ? pkgJsonPath : null;
+}
+/**
+ * Resolve how to launch ecweb as a real background process.
+ *
+ * On Windows, npm bins are usually .cmd shims. Launching that shim through a
+ * shell can create a visible console window; launching the package's JS entry
+ * through the current Node executable avoids that wrapper entirely.
+ */
+export function resolveEcwebLaunchCommand(ecwebArgs, opts = {}) {
+    const nodePath = opts.nodePath ?? process.execPath;
+    const installed = opts.installedPkg !== undefined ? opts.installedPkg : resolveGlobalPkg(WEB_PACKAGE_NAME);
+    let entry = installed?.path ? readEcwebPackageEntry(installed.path) : null;
+    if (entry) {
+        return { command: nodePath, args: [entry, ...ecwebArgs], entry, source: 'package-bin' };
+    }
+    const commandPath = opts.commandPath !== undefined ? opts.commandPath : resolveCommandPath(WEB_CLI_BIN);
+    if (!commandPath)
+        return null;
+    const shimPkgJson = packageJsonBesideNpmShim(commandPath, opts.isWindows ?? platformIsWindows);
+    entry = shimPkgJson ? readEcwebPackageEntry(shimPkgJson) : null;
+    if (entry) {
+        return { command: nodePath, args: [entry, ...ecwebArgs], entry, source: 'package-bin' };
+    }
+    // Windows: .cmd/.bat 文件需要通过 cmd.exe 执行
+    const isWindows = opts.isWindows ?? platformIsWindows;
+    if (isWindows && (commandPath.endsWith('.cmd') || commandPath.endsWith('.bat'))) {
+        return { command: 'cmd.exe', args: ['/c', commandPath, ...ecwebArgs], source: 'command' };
+    }
+    return { command: commandPath, args: ecwebArgs, source: 'command' };
+}
+/**
+ * ECWeb 配对码取码 helper（共享给 daemon 和 CLI）。
+ *
+ * 配对码是 ecweb 进程自己生成并持有的内部状态。daemon/CLI 通过 ecweb 的
+ * localhost-only HTTP 接口 GET /api/pair-code 取当前码（远程访问被 ecweb 403 拒绝）。
+ */
+/** 经 localhost 拉取 ecweb 当前配对码（仅本机可取）。失败返回 null。 */
+export async function fetchEcwebPairCode(port) {
+    try {
+        const resp = await fetch(`http://127.0.0.1:${port}/api/pair-code`, {
+            signal: AbortSignal.timeout(2000),
+        });
+        if (!resp.ok)
+            return null;
+        return await resp.json();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/error-dict.json

@@ -0,0 +1,153 @@
+{
+  "rules": [
+    {
+      "id": "context-too-long-cn",
+      "match": "上下文过长",
+      "action": "stop",
+      "type": "context_too_long",
+      "message": "⚠️ 上下文过长，请手动输入 /compact 压缩上下文"
+    },
+    {
+      "id": "context-too-long-en",
+      "match": "context too long",
+      "action": "stop",
+      "type": "context_too_long",
+      "message": "⚠️ 上下文过长，请手动输入 /compact 压缩上下文"
+    },
+    {
+      "id": "prompt-too-long",
+      "match": "prompt is too long",
+      "action": "stop",
+      "type": "context_too_long",
+      "message": "⚠️ 输入过长，请精简提问或使用 /compact 压缩上下文"
+    },
+    {
+      "id": "invalid-api-key",
+      "match": "invalid api key",
+      "action": "stop",
+      "type": "auth_error",
+      "message": "❌ API Key 无效，请检查密钥配置。使用 /status 查看当前配置"
+    },
+    {
+      "id": "key-not-found",
+      "match": "key_not_found",
+      "action": "stop",
+      "type": "auth_error",
+      "message": "❌ API Key 未找到，请检查密钥配置"
+    },
+    {
+      "id": "api-key-verifier-too-many-connections",
+      "match": "error 1040 (08004): too many connections",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 服务繁忙，请稍后重试"
+    },
+    {
+      "id": "credit-query-timeout",
+      "match": "积分查询超时",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ 积分查询超时，请稍后重试"
+    },
+    {
+      "id": "capacity-pool-switching-cn",
+      "match": "算力池切换",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ 当前算力池切换中，请稍后重试"
+    },
+    {
+      "id": "selected-model-at-capacity",
+      "match": "selected model is at capacity",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ 当前模型繁忙，请稍后重试"
+    },
+    {
+      "id": "api-error-400",
+      "match": "api error: 400",
+      "action": "stop",
+      "type": "api_error",
+      "message": "❌ 请求格式错误，请检查输入内容"
+    },
+    {
+      "id": "model-not-supported-403",
+      "match": "api error: 403 不支持该模型",
+      "action": "stop",
+      "type": "model_unavailable",
+      "message": "❌ 当前模型不受支持，请正确配置模型后重试"
+    },
+    {
+      "id": "api-error-403",
+      "match": "api error: 403",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 访问受限，请稍后重试"
+    },
+    {
+      "id": "api-error-429",
+      "match": "api error: 429",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ 请求过于频繁，请稍后重试"
+    },
+    {
+      "id": "api-error-500",
+      "match": "api error: 500",
+      "action": "retry",
+      "type": "api_error",
+      "message": "❌ API 服务暂时不可用，请稍后重试"
+    },
+    {
+      "id": "api-error-502",
+      "match": "api error: 502",
+      "action": "retry",
+      "type": "api_error"
+    },
+    {
+      "id": "api-error-503",
+      "match": "api error: 503",
+      "action": "retry",
+      "type": "api_error"
+    },
+    {
+      "id": "api-error-504",
+      "match": "api error: 504",
+      "action": "retry",
+      "type": "api_error"
+    },
+    {
+      "id": "not-valid-json",
+      "match": "is not valid json",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 返回异常响应，请稍后重试"
+    },
+    {
+      "id": "json-parse-error",
+      "match": "json parse error",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 返回 JSON 解析异常，请稍后重试"
+    },
+    {
+      "id": "feishu-permission",
+      "match": "im:resource",
+      "action": "stop",
+      "type": "unknown",
+      "message": "❌ 权限不足，请联系管理员配置应用权限"
+    },
+    {
+      "id": "stream-error",
+      "match": "stream",
+      "action": "retry",
+      "type": "stream_error"
+    },
+    {
+      "id": "request-aborted",
+      "match": "request was aborted",
+      "action": "ignore",
+      "type": "stream_error"
+    }
+  ]
+}