evolclaw 2.8.3 → 3.0.0

package/dist/core/session/session-mapper.js

@@ -0,0 +1,87 @@
+import { formatTimestamp } from './session-fs-store.js';
+export function sessionToFile(session) {
+    const metadata = {};
+    if (session.metadata) {
+        if (session.metadata.peerId)
+            metadata.peerId = session.metadata.peerId;
+        if (session.metadata.peerName)
+            metadata.peerName = session.metadata.peerName;
+        if (session.metadata.groupId)
+            metadata.groupId = session.metadata.groupId;
+        if (session.metadata.replyContext)
+            metadata.replyContext = session.metadata.replyContext;
+        if (session.metadata.agentSessions)
+            metadata.agentSessions = session.metadata.agentSessions;
+        if (session.metadata.resumeAt)
+            metadata.resumeAt = session.metadata.resumeAt;
+        for (const [k, v] of Object.entries(session.metadata)) {
+            if (['isActive', 'channelName', 'permissionMode', 'peerId', 'peerName', 'groupId', 'replyContext', 'agentSessions', 'resumeAt'].includes(k))
+                continue;
+            if (v !== undefined)
+                metadata[k] = v;
+        }
+    }
+    const now = session.updatedAt || Date.now();
+    return {
+        id: session.id,
+        channel: session.channel,
+        channelType: session.channelType || session.channel,
+        channelId: session.channelId,
+        selfId: session.selfId ?? null,
+        agentType: session.agentId || 'claude',
+        threadId: session.threadId || '',
+        chatType: session.chatType || 'private',
+        chatMode: session.sessionMode || 'interactive',
+        projectPath: session.projectPath,
+        agentSessionId: session.agentSessionId ?? null,
+        name: session.name ?? null,
+        activeTask: session.processingState ?? null,
+        permissionMode: session.metadata?.permissionMode || 'auto',
+        metadata,
+        createdAt: session.createdAt,
+        createdAtStr: formatTimestamp(session.createdAt),
+        updatedAt: now,
+        updatedAtStr: formatTimestamp(now),
+    };
+}
+export function fileToSession(file) {
+    const metadata = {};
+    if (file.metadata.peerId)
+        metadata.peerId = file.metadata.peerId;
+    if (file.metadata.peerName)
+        metadata.peerName = file.metadata.peerName;
+    if (file.metadata.groupId)
+        metadata.groupId = file.metadata.groupId;
+    if (file.metadata.replyContext)
+        metadata.replyContext = file.metadata.replyContext;
+    if (file.metadata.agentSessions)
+        metadata.agentSessions = file.metadata.agentSessions;
+    if (file.metadata.resumeAt)
+        metadata.resumeAt = file.metadata.resumeAt;
+    if (file.permissionMode)
+        metadata.permissionMode = file.permissionMode;
+    for (const [k, v] of Object.entries(file.metadata)) {
+        if (['peerId', 'peerName', 'groupId', 'replyContext', 'agentSessions', 'resumeAt'].includes(k))
+            continue;
+        if (v !== undefined)
+            metadata[k] = v;
+    }
+    return {
+        id: file.id,
+        channel: file.channel,
+        channelType: file.channelType,
+        channelId: file.channelId,
+        selfId: file.selfId ?? undefined,
+        agentId: file.agentType,
+        threadId: file.threadId,
+        chatType: file.chatType,
+        sessionMode: file.chatMode,
+        projectPath: file.projectPath,
+        agentSessionId: file.agentSessionId ?? undefined,
+        name: file.name ?? undefined,
+        processingState: file.activeTask ?? undefined,
+        metadata,
+        createdAt: file.createdAt,
+        updatedAt: file.updatedAt,
+    };
+}

package/dist/core/trigger/manager.js

@@ -0,0 +1,122 @@
+import fs from 'fs';
+import path from 'path';
+import { atomicWriteJson, appendJsonl } from '../session/session-fs-store.js';
+import { logger } from '../../utils/logger.js';
+export class TriggerManager {
+    aid;
+    triggersPath;
+    historyPath;
+    triggers = new Map();
+    constructor(aid, triggersDir) {
+        this.aid = aid;
+        fs.mkdirSync(triggersDir, { recursive: true });
+        this.triggersPath = path.join(triggersDir, 'triggers.json');
+        this.historyPath = path.join(triggersDir, 'history.jsonl');
+    }
+    load() {
+        if (!fs.existsSync(this.triggersPath)) {
+            this.triggers = new Map();
+            return [];
+        }
+        try {
+            const raw = fs.readFileSync(this.triggersPath, 'utf8');
+            const data = JSON.parse(raw);
+            this.triggers = new Map(Object.entries(data.triggers ?? {}));
+            return [...this.triggers.values()];
+        }
+        catch (e) {
+            logger.warn(`[TriggerManager] Failed to parse ${this.triggersPath}, starting empty: ${e}`);
+            this.triggers = new Map();
+            return [];
+        }
+    }
+    save() {
+        const data = {
+            version: 1,
+            triggers: Object.fromEntries(this.triggers),
+        };
+        atomicWriteJson(this.triggersPath, data);
+    }
+    register(trigger) {
+        if (this.triggers.has(trigger.id)) {
+            throw new Error(`触发器 ID 已存在：${trigger.id}`);
+        }
+        // Check name uniqueness within this agent
+        for (const t of this.triggers.values()) {
+            if (t.name === trigger.name) {
+                throw new Error(`触发器名称已存在：${trigger.name}`);
+            }
+        }
+        this.triggers.set(trigger.id, trigger);
+        this.save();
+    }
+    getById(id) {
+        return this.triggers.get(id);
+    }
+    getByName(name) {
+        for (const t of this.triggers.values()) {
+            if (t.name === name)
+                return t;
+        }
+        return undefined;
+    }
+    // Scoped lookup: only returns triggers owned by (peerId, channel) — prevents info disclosure
+    getByNameScoped(name, peerId, channel) {
+        for (const t of this.triggers.values()) {
+            if (t.name === name && t.createdByPeerId === peerId && t.createdByChannel === channel)
+                return t;
+        }
+        return undefined;
+    }
+    // Scoped ID lookup: allows creator to cancel by UUID without revealing others' triggers
+    getByIdScoped(id, peerId, channel) {
+        const t = this.triggers.get(id);
+        if (t && t.createdByPeerId === peerId && t.createdByChannel === channel)
+            return t;
+        return undefined;
+    }
+    listActive() {
+        return [...this.triggers.values()].sort((a, b) => a.nextFireAt - b.nextFireAt);
+    }
+    listAll() {
+        const active = this.listActive();
+        const history = [];
+        if (fs.existsSync(this.historyPath)) {
+            const lines = fs.readFileSync(this.historyPath, 'utf8').split('\n').filter(Boolean);
+            for (const line of lines) {
+                try {
+                    history.push(JSON.parse(line));
+                }
+                catch { /* skip malformed */ }
+            }
+        }
+        return { active, history };
+    }
+    updateFireStats(id, firedAt) {
+        const t = this.triggers.get(id);
+        if (!t)
+            return;
+        t.lastFiredAt = firedAt;
+        t.fireCount += 1;
+        t.updatedAt = Date.now();
+        this.save();
+    }
+    updateNextFireAt(id, nextFireAt) {
+        const t = this.triggers.get(id);
+        if (!t)
+            return;
+        t.nextFireAt = nextFireAt;
+        t.updatedAt = Date.now();
+        this.save();
+    }
+    moveToDone(id, reason) {
+        const t = this.triggers.get(id);
+        if (!t)
+            return undefined;
+        this.triggers.delete(id);
+        this.save();
+        const entry = { ...t, doneAt: Date.now(), doneReason: reason };
+        appendJsonl(this.historyPath, entry);
+        return t;
+    }
+}

package/dist/core/trigger/parser.js

@@ -0,0 +1,128 @@
+import { CronExpressionParser } from 'cron-parser';
+// Note: unquoted multi-word values (e.g. --prompt=hello world) are not supported.
+// The second word would be treated as an unknown token. Always quote multi-word values:
+//   --prompt "hello world"  or  --prompt='hello world'
+function parseFlags(args) {
+    const flags = new Map();
+    const re = /--(\w[\w-]*)(?:=("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+)|(?:\s+(?!--)("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+))?)?/g;
+    let m;
+    while ((m = re.exec(args)) !== null) {
+        const key = m[1];
+        const val = m[2] ?? m[3];
+        if (val === undefined) {
+            flags.set(key, true);
+        }
+        else {
+            flags.set(key, val.replace(/^["']|["']$/g, ''));
+        }
+    }
+    return flags;
+}
+export function parseDuration(s) {
+    const re = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/;
+    const m = re.exec(s.trim().toLowerCase());
+    if (!m || !s.trim())
+        return null;
+    const [, d, h, min, sec] = m;
+    const total = (parseInt(d ?? '0') * 86400 +
+        parseInt(h ?? '0') * 3600 +
+        parseInt(min ?? '0') * 60 +
+        parseInt(sec ?? '0')) * 1000;
+    return total > 0 ? total : null;
+}
+export function parseIsoDate(s) {
+    const d = new Date(s);
+    return isNaN(d.getTime()) ? null : d.getTime();
+}
+export function validateCronExpr(expr) {
+    try {
+        CronExpressionParser.parse(expr);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function parseTriggerSet(args) {
+    const flags = parseFlags(args);
+    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 === 0) {
+        return { ok: false, error: '必须指定时间参数：--delay <时长> | --at <ISO时间> | --cron <表达式>' };
+    }
+    if (timeCount > 1) {
+        return { ok: false, error: '--delay、--at、--cron 互斥，只能指定一个' };
+    }
+    let scheduleType;
+    let scheduleValue;
+    if (hasDelay) {
+        const raw = flags.get('delay');
+        const ms = parseDuration(raw);
+        if (ms === null) {
+            return { ok: false, error: `无法解析 --delay "${raw}"，支持格式：30m、2h、1d、2h30m` };
+        }
+        scheduleType = 'delay';
+        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}` };
+        }
+        scheduleType = 'at';
+        scheduleValue = new Date(ts).toISOString();
+    }
+    else {
+        const raw = flags.get('cron');
+        if (!validateCronExpr(raw)) {
+            return { ok: false, error: `无效的 cron 表达式："${raw}"` };
+        }
+        scheduleType = 'cron';
+        scheduleValue = raw;
+    }
+    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 字符限制' };
+    }
+    const hasThread = flags.has('thread');
+    const hasSession = flags.has('session');
+    if (hasThread && hasSession) {
+        return { ok: false, error: '--thread 与 --session 互斥，只能指定一个' };
+    }
+    const hasChannel = flags.has('channel');
+    const hasChannelId = flags.has('channelid');
+    if (hasChannel !== hasChannelId) {
+        return { ok: false, error: '--channel 与 --channelid 必须同时指定或同时省略' };
+    }
+    let targetSessionStrategy = 'latest';
+    if (hasSession) {
+        const sv = flags.get('session');
+        if (sv !== 'latest' && sv !== 'silent') {
+            return { ok: false, error: '--session 只接受 latest 或 silent' };
+        }
+        targetSessionStrategy = sv;
+    }
+    return {
+        ok: true,
+        value: {
+            scheduleType,
+            scheduleValue,
+            targetChannel: hasChannel ? flags.get('channel') : undefined,
+            targetChannelId: hasChannelId ? flags.get('channelid') : undefined,
+            targetThreadId: hasThread ? flags.get('thread') : undefined,
+            targetSessionStrategy,
+            agentId: flags.has('agent') ? flags.get('agent') : undefined,
+            name: flags.has('name') ? flags.get('name') : undefined,
+            prompt: prompt,
+        },
+    };
+}

package/dist/core/trigger/scheduler.js

@@ -0,0 +1,224 @@
+import { CronExpressionParser } from 'cron-parser';
+import { logger as baseLogger } from '../../utils/logger.js';
+const logger = {
+    info: (msg) => baseLogger.info(msg),
+    warn: (msg) => baseLogger.warn(msg),
+    debug: (msg) => baseLogger.debug(msg),
+};
+// Min-heap ordered by nextFireAt
+class TriggerHeap {
+    heap = [];
+    push(t) {
+        this.heap.push(t);
+        this.bubbleUp(this.heap.length - 1);
+    }
+    pop() {
+        if (this.heap.length === 0)
+            return undefined;
+        const top = this.heap[0];
+        const last = this.heap.pop();
+        if (this.heap.length > 0) {
+            this.heap[0] = last;
+            this.sinkDown(0);
+        }
+        return top;
+    }
+    peek() {
+        return this.heap[0];
+    }
+    remove(id) {
+        const idx = this.heap.findIndex(t => t.id === id);
+        if (idx === -1)
+            return false;
+        const last = this.heap.pop();
+        if (idx < this.heap.length) {
+            this.heap[idx] = last;
+            this.bubbleUp(idx);
+            this.sinkDown(idx);
+        }
+        return true;
+    }
+    bubbleUp(i) {
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            if (this.heap[parent].nextFireAt <= this.heap[i].nextFireAt)
+                break;
+            [this.heap[parent], this.heap[i]] = [this.heap[i], this.heap[parent]];
+            i = parent;
+        }
+    }
+    sinkDown(i) {
+        const n = this.heap.length;
+        while (true) {
+            let smallest = i;
+            const l = 2 * i + 1, r = 2 * i + 2;
+            if (l < n && this.heap[l].nextFireAt < this.heap[smallest].nextFireAt)
+                smallest = l;
+            if (r < n && this.heap[r].nextFireAt < this.heap[smallest].nextFireAt)
+                smallest = r;
+            if (smallest === i)
+                break;
+            [this.heap[smallest], this.heap[i]] = [this.heap[i], this.heap[smallest]];
+            i = smallest;
+        }
+    }
+    get size() { return this.heap.length; }
+}
+/**
+ * Calculate the next fire timestamp for a trigger.
+ *
+ * For `delay` type: `now` is the reference point — returns `now + delayMs`.
+ *   Pass `Date.now()` at registration time to get the original fire time.
+ *   Do NOT pass a stored `nextFireAt` as `now` — that would double-add the delay.
+ * For `at` type: `now` is ignored; returns the absolute ISO timestamp.
+ * For `cron` type: returns the next occurrence after `now`.
+ */
+export function calcNextFireAt(scheduleType, scheduleValue, now = Date.now()) {
+    if (scheduleType === 'delay') {
+        return now + parseInt(scheduleValue);
+    }
+    if (scheduleType === 'at') {
+        return new Date(scheduleValue).getTime();
+    }
+    // cron
+    const interval = CronExpressionParser.parse(scheduleValue, { currentDate: new Date(now) });
+    return interval.next().getTime();
+}
+export class TriggerScheduler {
+    aid;
+    manager;
+    eventBus;
+    heap = new TriggerHeap();
+    timer = null;
+    inflightCron = new Set(); // trigger IDs currently executing (cron)
+    fireCallback;
+    constructor(aid, manager, eventBus) {
+        this.aid = aid;
+        this.manager = manager;
+        this.eventBus = eventBus;
+    }
+    setFireCallback(cb) {
+        this.fireCallback = cb;
+    }
+    async init() {
+        const triggers = this.manager.load();
+        const now = Date.now();
+        for (const t of triggers) {
+            if (t.scheduleType === 'cron') {
+                // Recalculate next fire from now (don't backfill missed cron runs)
+                const next = calcNextFireAt('cron', t.scheduleValue, now);
+                if (next !== t.nextFireAt) {
+                    this.manager.updateNextFireAt(t.id, next);
+                    t.nextFireAt = next;
+                }
+                this.heap.push(t);
+            }
+            else {
+                // delay/at: if missed, fire immediately (backfill)
+                if (t.nextFireAt < now) {
+                    logger.info(`[${this.aid}] Backfilling missed trigger: ${t.name} (${t.id})`);
+                    this.heap.push({ ...t, nextFireAt: now });
+                }
+                else {
+                    this.heap.push(t);
+                }
+            }
+        }
+        this.resetTimer();
+        logger.info(`[${this.aid}] Scheduler initialized with ${triggers.length} trigger(s)`);
+    }
+    register(trigger) {
+        this.heap.push(trigger);
+        this.resetTimer();
+        this.eventBus.publish({ type: 'trigger:registered', triggerId: trigger.id, name: trigger.name, peerId: trigger.createdByPeerId });
+    }
+    cancel(id) {
+        this.heap.remove(id);
+        this.inflightCron.delete(id);
+        this.resetTimer();
+    }
+    stop() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.inflightCron.clear();
+    }
+    resetTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        const top = this.heap.peek();
+        if (!top)
+            return;
+        const delay = Math.max(0, top.nextFireAt - Date.now());
+        this.timer = setTimeout(() => this.onFire(), delay);
+    }
+    onFire() {
+        this.timer = null;
+        const now = Date.now();
+        // Fire all triggers that are due
+        while (this.heap.peek() && this.heap.peek().nextFireAt <= now + 50) {
+            const trigger = this.heap.pop();
+            if (trigger.scheduleType === 'cron' && this.inflightCron.has(trigger.id)) {
+                // Previous run still in flight — skip
+                logger.warn(`[${this.aid}] Cron trigger ${trigger.name} still running, skipping`);
+                this.eventBus.publish({ type: 'trigger:skipped', triggerId: trigger.id, reason: 'overlap' });
+                // Re-schedule next cron occurrence
+                const next = calcNextFireAt('cron', trigger.scheduleValue, now);
+                this.manager.updateNextFireAt(trigger.id, next);
+                this.heap.push({ ...trigger, nextFireAt: next });
+                continue;
+            }
+            this.fireTrigger(trigger, now);
+        }
+        this.resetTimer();
+    }
+    fireTrigger(trigger, now) {
+        const messageId = `trigger:${trigger.id}:${now}`;
+        const msg = this.buildSyntheticMessage(trigger, messageId);
+        logger.info(`[${this.aid}] Firing trigger: ${trigger.name} (${trigger.id})`);
+        // Update stats before moving to done so history captures the updated count
+        this.manager.updateFireStats(trigger.id, now);
+        if (trigger.scheduleType === 'cron') {
+            this.inflightCron.add(trigger.id);
+            // Re-schedule next occurrence
+            const next = calcNextFireAt('cron', trigger.scheduleValue, now);
+            this.manager.updateNextFireAt(trigger.id, next);
+            this.heap.push({ ...trigger, nextFireAt: next });
+        }
+        else {
+            // delay/at: one-shot, move to done
+            this.manager.moveToDone(trigger.id, 'fired');
+        }
+        this.eventBus.publish({ type: 'trigger:fired', triggerId: trigger.id, name: trigger.name, fireTime: now });
+        if (this.fireCallback) {
+            this.fireCallback(msg, trigger);
+        }
+    }
+    // Called by MessageProcessor when a trigger message completes/fails/is interrupted
+    onTriggerComplete(triggerId, _outcome) {
+        // Only clear inflight state — message-processor already published the relevant events
+        this.inflightCron.delete(triggerId);
+    }
+    buildSyntheticMessage(trigger, messageId) {
+        return {
+            channel: trigger.targetChannel,
+            channelId: trigger.targetChannelId,
+            selfId: this.aid,
+            threadId: trigger.targetThreadId ?? '',
+            agentId: trigger.agentId,
+            chatType: 'private',
+            peerId: `__trigger__:${trigger.id}`, // unique per trigger to prevent greedy merge
+            content: trigger.prompt,
+            messageId,
+            timestamp: Date.now(),
+            source: 'trigger',
+            triggerMeta: {
+                triggerId: trigger.id,
+                silent: trigger.targetSessionStrategy === 'silent',
+            },
+        };
+    }
+}

package/dist/{templates → data}/prompts.md

@@ -24,12 +24,44 @@
 可多次调用发送多条消息 ，如果不想回复停止调用即可。
 禁止使用 AskUserQuestion 和 ExitPlanMode 工具——proactive 模式下应由你主动用 ctl send 与用户沟通。
 
+## trigger
+
+[触发器] 你可以通过 /trigger 命令设置延迟或定时任务，系统会在指定时间重新激活你执行任务。
+
+注册触发器：
+/trigger set --delay <时长> --prompt "<任务内容>"        延迟执行，如 30m、2h、1d
+/trigger set --at <ISO时间> --prompt "<任务内容>"        指定时刻，如 2026-05-15T09:00
+/trigger set --cron <表达式> --prompt "<任务内容>"       周期执行，如 "0 9 * * *"
+
+定位参数（默认当前上下文）：
+  --channel <实例名>     目标通道实例
+  --channelid <id>       目标对话 ID
+  --thread <id>          目标 thread（与 --session 互斥，需通道支持）
+  --session latest       续接最后活跃会话（默认，用户可见输出）
+  --session silent       新建独立会话静默执行（不打扰用户，适合后台任务）
+
+其他参数：
+  --name <标识>          触发器名称（默认自动生成）
+  --agent <名称>         目标 agent（默认当前）
+
+管理：
+/trigger                 查看活跃触发器
+/trigger list            查看所有触发器（含历史）
+/trigger cancel <名称>   取消触发器
+
+使用原则：
+- 用户要求"稍后/明天/定时"做某事时使用
+- 你判断某任务需要延迟到特定时刻才合适时主动使用
+- silent 适合：清理、扫描、生成文件等后台任务
+- latest 适合：提醒用户、跟进对话、结果需要用户看到
+- 触发器不支持修改，改内容请 cancel 后重建
+
 
 ---
 
 ## 格式说明
 
-模板由多个以 `## 段名` 分隔的段组成，加载器只识别 `runtime`、`group`、`proactive` 三段，其它段（包括本说明）会被忽略，可以随意增删。
+模板由多个以 `## 段名` 分隔的段组成，加载器只识别 `runtime`、`group`、`proactive`、`trigger` 四段，其它段（包括本说明）会被忽略，可以随意增删。
 
 **占位符语法：**
 
@@ -46,6 +78,7 @@
 | `runtime` | 每次消息 | 每条用户消息都会注入 |
 | `group` | `chatType === 'group' && peerId` | 仅群聊消息注入 |
 | `proactive` | `sessionMode === 'proactive'` | 仅 proactive 会话注入 |
+| `trigger` | 非触发器来源的消息 | 让 AI 知道可以使用 /trigger 命令 |
 
 三段以换行拼接，追加到该消息的 system prompt 末尾。