evolclaw 3.0.0 → 3.1.1

package/dist/core/trigger/parser.js

@@ -43,6 +43,116 @@ export function validateCronExpr(expr) {
         return false;
     }
 }
+export function parseTriggerUpdate(args) {
+    // First token is the trigger name/id, rest is flags
+    const trimmed = args.trim();
+    if (!trimmed) {
+        return { ok: false, error: '用法：/trigger update <名称|ID> [--参数...]' };
+    }
+    // Extract nameOrId: first non-flag token (could be quoted)
+    let nameOrId;
+    let rest;
+    if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
+        const quote = trimmed[0];
+        const end = trimmed.indexOf(quote, 1);
+        if (end === -1) {
+            return { ok: false, error: '名称引号未闭合' };
+        }
+        nameOrId = trimmed.slice(1, end);
+        rest = trimmed.slice(end + 1).trim();
+    }
+    else {
+        const spaceIdx = trimmed.indexOf(' ');
+        if (spaceIdx === -1) {
+            return { ok: false, error: '至少需要指定一个修改参数（如 --prompt、--delay 等）' };
+        }
+        nameOrId = trimmed.slice(0, spaceIdx);
+        rest = trimmed.slice(spaceIdx + 1).trim();
+    }
+    if (!rest) {
+        return { ok: false, error: '至少需要指定一个修改参数（如 --prompt、--delay 等）' };
+    }
+    const flags = parseFlags(rest);
+    if (flags.size === 0) {
+        return { ok: false, error: '至少需要指定一个修改参数（如 --prompt、--delay 等）' };
+    }
+    const result = {};
+    // Parse schedule if provided (only one allowed)
+    const hasDelay = flags.has('delay');
+    const hasAt = flags.has('at');
+    const hasCron = flags.has('cron');
+    const timeCount = [hasDelay, hasAt, hasCron].filter(Boolean).length;
+    if (timeCount > 1) {
+        return { ok: false, error: '--delay、--at、--cron 互斥，只能指定一个' };
+    }
+    if (hasDelay) {
+        const raw = flags.get('delay');
+        const ms = parseDuration(raw);
+        if (ms === null)
+            return { ok: false, error: `无法解析 --delay "${raw}"，支持格式：30m、2h、1d、2h30m` };
+        result.scheduleType = 'delay';
+        result.scheduleValue = String(ms);
+    }
+    else if (hasAt) {
+        const raw = flags.get('at');
+        const ts = parseIsoDate(raw);
+        if (ts === null)
+            return { ok: false, error: `无法解析 --at "${raw}"，请使用 ISO 格式，如 2026-05-15T09:00` };
+        if (ts <= Date.now())
+            return { ok: false, error: `--at 时间已过期：${raw}` };
+        result.scheduleType = 'at';
+        result.scheduleValue = new Date(ts).toISOString();
+    }
+    else if (hasCron) {
+        const raw = flags.get('cron');
+        if (!validateCronExpr(raw))
+            return { ok: false, error: `无效的 cron 表达式："${raw}"` };
+        result.scheduleType = 'cron';
+        result.scheduleValue = raw;
+    }
+    // Parse optional fields
+    if (flags.has('prompt')) {
+        const prompt = flags.get('prompt');
+        if (!prompt || prompt === true)
+            return { ok: false, error: '--prompt 不能为空' };
+        if (typeof prompt === 'string' && prompt.length > 4096)
+            return { ok: false, error: '--prompt 超过 4096 字符限制' };
+        result.prompt = prompt;
+    }
+    if (flags.has('name')) {
+        const name = flags.get('name');
+        if (!name || name === true)
+            return { ok: false, error: '--name 不能为空' };
+        result.name = name;
+    }
+    if (flags.has('session')) {
+        const sv = flags.get('session');
+        if (sv !== 'latest' && sv !== 'silent')
+            return { ok: false, error: '--session 只接受 latest 或 silent' };
+        result.targetSessionStrategy = sv;
+    }
+    if (flags.has('agent')) {
+        const agent = flags.get('agent');
+        if (!agent || agent === true)
+            return { ok: false, error: '--agent 不能为空' };
+        result.agentId = agent;
+    }
+    const hasChannel = flags.has('channel');
+    const hasChannelId = flags.has('channelid');
+    if (hasChannel !== hasChannelId) {
+        return { ok: false, error: '--channel 与 --channelid 必须同时指定或同时省略' };
+    }
+    if (hasChannel) {
+        result.targetChannel = flags.get('channel');
+        result.targetChannelId = flags.get('channelid');
+    }
+    if (flags.has('thread')) {
+        if (flags.has('session'))
+            return { ok: false, error: '--thread 与 --session 互斥' };
+        result.targetThreadId = flags.get('thread');
+    }
+    return { ok: true, nameOrId, value: result };
+}
 export function parseTriggerSet(args) {
     const flags = parseFlags(args);
     const hasDelay = flags.has('delay');

package/dist/core/trigger/scheduler.js

@@ -137,6 +137,12 @@ export class TriggerScheduler {
         this.inflightCron.delete(id);
         this.resetTimer();
     }
+    update(trigger) {
+        this.heap.remove(trigger.id);
+        this.heap.push(trigger);
+        this.resetTimer();
+        this.eventBus.publish({ type: 'trigger:updated', triggerId: trigger.id, name: trigger.name, peerId: trigger.createdByPeerId });
+    }
     stop() {
         if (this.timer) {
             clearTimeout(this.timer);
@@ -153,7 +159,7 @@ export class TriggerScheduler {
         if (!top)
             return;
         const delay = Math.max(0, top.nextFireAt - Date.now());
-        this.timer = setTimeout(() => this.onFire(), delay);
+        this.timer = setTimeout(() => this.onFire(), delay).unref();
     }
     onFire() {
         this.timer = null;

package/dist/data/error-dict.json

@@ -0,0 +1,118 @@
+{
+  "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": "credit-query-timeout",
+      "match": "积分查询超时",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ 积分查询超时，正在重试..."
+    },
+    {
+      "id": "api-error-400",
+      "match": "api error: 400",
+      "action": "stop",
+      "type": "api_error",
+      "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": "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"
+    }
+  ]
+}

package/dist/eck/baseagent-caps.js

@@ -0,0 +1,18 @@
+export const BASEAGENT_CAPS = {
+    'claude-code': {
+        autoLoadsRules: true,
+        supportsSystemPrompt: true,
+    },
+    'claude': {
+        autoLoadsRules: true,
+        supportsSystemPrompt: true,
+    },
+    'codex': {
+        autoLoadsRules: false,
+        supportsSystemPrompt: true,
+    },
+    'gemini': {
+        autoLoadsRules: false,
+        supportsSystemPrompt: true,
+    },
+};

package/dist/eck/detect.js

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import path from 'path';
+import { BASEAGENT_CAPS } from './baseagent-caps.js';
+const MAX_DEPTH = 5;
+export function resolveEckInjection(agentConfig, projectPath, kitsRulesPath) {
+    const caps = BASEAGENT_CAPS[agentConfig.baseAgent]
+        ?? { autoLoadsRules: false, supportsSystemPrompt: true };
+    if (!caps.autoLoadsRules) {
+        return { shouldInject: true, reason: 'baseagent-no-autoload' };
+    }
+    const symlinkActive = detectEckSymlink(projectPath, kitsRulesPath);
+    if (symlinkActive) {
+        return { shouldInject: false, reason: 'symlink-active' };
+    }
+    return { shouldInject: true, reason: 'symlink-not-found' };
+}
+export function detectEckSymlink(projectPath, kitsRulesPath) {
+    let dir = projectPath;
+    let depth = 0;
+    while (depth < MAX_DEPTH) {
+        const eckDir = path.join(dir, '.claude', 'rules', 'eck');
+        if (fs.existsSync(eckDir)) {
+            try {
+                const realPath = fs.realpathSync(eckDir);
+                const kitsRulesReal = fs.realpathSync(kitsRulesPath);
+                if (pathEquals(realPath, kitsRulesReal)) {
+                    return true;
+                }
+            }
+            catch {
+                // detection failure → conservatively assume not loaded
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+        depth++;
+    }
+    return false;
+}
+function pathEquals(a, b) {
+    if (process.platform === 'win32') {
+        return path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase();
+    }
+    return path.resolve(a) === path.resolve(b);
+}

package/dist/eck/init.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths, kitsDocsDir, agentDir, getPackageRoot } from '../paths.js';
+import { atomicWriteText } from '../utils/atomic-write.js';
+import { logger } from '../utils/logger.js';
+export function initEck() {
+    const p = resolvePaths();
+    const eckDir = p.eckDir;
+    fs.mkdirSync(eckDir, { recursive: true });
+    initEckRuntime(eckDir);
+    initEckPathRegistry(eckDir);
+}
+export function initAgentIndex(aid) {
+    const indexDir = path.join(agentDir(aid), 'index');
+    fs.mkdirSync(indexDir, { recursive: true });
+    const indexFile = path.join(indexDir, 'INDEX.md');
+    const guideFile = path.join(indexDir, 'GUIDE.md');
+    if (!fs.existsSync(indexFile)) {
+        const template = loadTemplate('INDEX.template.md');
+        if (template) {
+            atomicWriteText(indexFile, renderTemplate(template, { AID: aid }));
+            logger.info(`[eck] Created ${indexFile}`);
+        }
+    }
+    if (!fs.existsSync(guideFile)) {
+        const template = loadTemplate('GUIDE.template.md');
+        if (template) {
+            atomicWriteText(guideFile, renderTemplate(template, { AID: aid }));
+            logger.info(`[eck] Created ${guideFile}`);
+        }
+    }
+}
+function initEckRuntime(eckDir) {
+    const runtimeFile = path.join(eckDir, 'runtime.md');
+    if (fs.existsSync(runtimeFile))
+        return;
+    const template = loadTemplate('runtime.template.md');
+    if (!template)
+        return;
+    const vars = {
+        EVOLCLAW_HOME: resolvePaths().root,
+        PACKAGE_ROOT: getPackageRoot(),
+    };
+    atomicWriteText(runtimeFile, renderTemplate(template, vars));
+    logger.info(`[eck] Created ${runtimeFile}`);
+}
+function initEckPathRegistry(eckDir) {
+    const registryFile = path.join(eckDir, 'path-registry.md');
+    if (fs.existsSync(registryFile))
+        return;
+    const template = loadTemplate('path-registry.template.md');
+    if (!template)
+        return;
+    const vars = {
+        EVOLCLAW_HOME: resolvePaths().root,
+        PACKAGE_ROOT: getPackageRoot(),
+    };
+    atomicWriteText(registryFile, renderTemplate(template, vars));
+    logger.info(`[eck] Created ${registryFile}`);
+}
+function loadTemplate(filename) {
+    const templatePath = path.join(kitsDocsDir(), 'eck_templates', filename);
+    try {
+        return fs.readFileSync(templatePath, 'utf-8');
+    }
+    catch {
+        logger.warn(`[eck] Template not found: ${templatePath}`);
+        return null;
+    }
+}
+function renderTemplate(template, vars) {
+    let result = template;
+    for (const [key, value] of Object.entries(vars)) {
+        result = result.replaceAll(`{{${key}}}`, value);
+    }
+    return result;
+}

package/dist/eck/rules-loader.js

@@ -0,0 +1,28 @@
+import fs from 'fs';
+import path from 'path';
+import { kitsRulesDir } from '../paths.js';
+let _cachedRules = null;
+export function loadRulesForInjection() {
+    if (_cachedRules !== null)
+        return _cachedRules;
+    const rulesDir = kitsRulesDir();
+    if (!fs.existsSync(rulesDir)) {
+        _cachedRules = '';
+        return '';
+    }
+    const files = fs.readdirSync(rulesDir)
+        .filter(f => f.endsWith('.md'))
+        .sort();
+    const parts = [];
+    for (const file of files) {
+        try {
+            parts.push(fs.readFileSync(path.join(rulesDir, file), 'utf-8'));
+        }
+        catch { /* skip unreadable files */ }
+    }
+    _cachedRules = parts.join('\n\n');
+    return _cachedRules;
+}
+export function invalidateRulesCache() {
+    _cachedRules = null;
+}