evolcore 0.0.28 → 0.0.29

package/dist/core/session/session-idle-monitor.js

@@ -0,0 +1,355 @@
+import fs from 'fs';
+import path from 'path';
+import { logger } from '../../utils/logger.js';
+import { atomicWriteJson } from './session-fs-store.js';
+import { createRootCausation } from '../causation/context.js';
+export const MIN_SESSION_IDLE_SECONDS = 30;
+/**
+ * Publishes one session:idle event after a runner task ends, using the
+ * per-session relation configuration as the idle period.
+ * Trigger-generated terminal events from session:idle consumers are excluded
+ * using the trigger causation path to avoid resetting the idle cycle they caused.
+ */
+export class SessionIdleMonitor {
+    options;
+    sessions = new Map();
+    timers = new Map();
+    generations = new Map();
+    knownSessionIdleTriggerIds = new Set();
+    taskEncryption = new Map();
+    started = false;
+    active = false;
+    onTaskTerminal = (event) => {
+        if (!isTaskTerminalEvent(event) || !event.sessionId)
+            return;
+        this.refreshSessionIdleTriggerIds();
+        const triggerPath = event.causation?.trigger?.path ?? [];
+        if (triggerPath.some(node => this.knownSessionIdleTriggerIds.has(node.triggerId))) {
+            this.taskEncryption.delete(event.sessionId);
+            return;
+        }
+        const timestamp = 'timestamp' in event && typeof event.timestamp === 'number' && Number.isFinite(event.timestamp)
+            ? event.timestamp
+            : this.now();
+        const eventEncrypted = 'encrypted' in event && typeof event.encrypted === 'boolean' ? event.encrypted : undefined;
+        const encrypted = eventEncrypted
+            ?? this.taskEncryption.get(event.sessionId)
+            ?? this.options.getSessionEncrypt?.(event.sessionId);
+        this.recordActivity(event.sessionId, timestamp, encrypted);
+        this.taskEncryption.delete(event.sessionId);
+    };
+    onTaskStarted = (event) => {
+        if (event.type !== 'task:started' || !event.sessionId)
+            return;
+        if (typeof event.encrypt === 'boolean')
+            this.taskEncryption.set(event.sessionId, event.encrypt);
+        else
+            this.taskEncryption.delete(event.sessionId);
+    };
+    onSessionDeleted = (event) => {
+        if (event.type === 'session:deleted')
+            this.clearSession(event.sessionId);
+    };
+    onSessionSwitched = (event) => {
+        if (event.type !== 'session:switched')
+            return;
+        this.clearSession(event.fromSessionId);
+        this.clearSession(event.toSessionId);
+    };
+    constructor(options) {
+        this.options = options;
+        this.loadState();
+    }
+    /** Subscribe early so startup task completions are captured before triggers start. */
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.options.eventBus.subscribe('task:completed', this.onTaskTerminal);
+        this.options.eventBus.subscribe('task:error', this.onTaskTerminal);
+        this.options.eventBus.subscribe('task:interrupted', this.onTaskTerminal);
+        this.options.eventBus.subscribe('task:started', this.onTaskStarted);
+        this.options.eventBus.subscribe('session:deleted', this.onSessionDeleted);
+        this.options.eventBus.subscribe('session:switched', this.onSessionSwitched);
+    }
+    /** Arm restored timers only after event-trigger subscriptions are registered. */
+    activate() {
+        if (this.active)
+            return;
+        this.active = true;
+        this.refreshSessionIdleTriggerIds();
+        for (const sessionId of this.sessions.keys())
+            this.scheduleSession(sessionId);
+    }
+    /** Re-read relation configuration and re-arm every restored/current session. */
+    refresh() {
+        if (!this.active)
+            return;
+        for (const sessionId of this.sessions.keys()) {
+            this.clearTimers(sessionId);
+            this.generations.set(sessionId, (this.generations.get(sessionId) ?? 0) + 1);
+            this.scheduleSession(sessionId);
+        }
+    }
+    stop() {
+        this.active = false;
+        this.clearAllTimers();
+        if (!this.started)
+            return;
+        this.started = false;
+        this.options.eventBus.unsubscribe('task:completed', this.onTaskTerminal);
+        this.options.eventBus.unsubscribe('task:error', this.onTaskTerminal);
+        this.options.eventBus.unsubscribe('task:interrupted', this.onTaskTerminal);
+        this.options.eventBus.unsubscribe('task:started', this.onTaskStarted);
+        this.options.eventBus.unsubscribe('session:deleted', this.onSessionDeleted);
+        this.options.eventBus.unsubscribe('session:switched', this.onSessionSwitched);
+    }
+    now() {
+        return this.options.now?.() ?? Date.now();
+    }
+    recordActivity(sessionId, lastEndedAt, encrypted) {
+        const current = this.sessions.get(sessionId);
+        if (current && current.lastEndedAt > lastEndedAt)
+            return;
+        this.clearTimers(sessionId);
+        this.generations.set(sessionId, (this.generations.get(sessionId) ?? 0) + 1);
+        this.sessions.set(sessionId, {
+            lastEndedAt,
+            emitted: false,
+            ...(typeof encrypted === 'boolean' ? { encrypted } : {}),
+        });
+        this.persistState();
+        if (this.active)
+            this.scheduleSession(sessionId);
+    }
+    clearSession(sessionId) {
+        if (!sessionId)
+            return;
+        this.taskEncryption.delete(sessionId);
+        this.clearTimers(sessionId);
+        this.generations.set(sessionId, (this.generations.get(sessionId) ?? 0) + 1);
+        if (this.sessions.delete(sessionId))
+            this.persistState();
+    }
+    scheduleSession(sessionId) {
+        void this.scheduleSessionAsync(sessionId);
+    }
+    async scheduleSessionAsync(sessionId) {
+        const state = this.sessions.get(sessionId);
+        if (!state || !this.active)
+            return;
+        const generation = this.generations.get(sessionId) ?? 0;
+        if (this.timers.has(sessionId) || state.emitted)
+            return;
+        let session;
+        try {
+            session = await this.options.getSessionById(sessionId);
+        }
+        catch (error) {
+            this.warn(`Failed to load session ${sessionId} while scheduling idle check`, error);
+            return;
+        }
+        if (!this.isCurrentCycle(sessionId, state.lastEndedAt, generation))
+            return;
+        if (!session || session.deletedAt) {
+            this.clearSession(sessionId);
+            return;
+        }
+        if (!isSupportedSession(session))
+            return;
+        const idleSeconds = await this.readIdleSeconds(session);
+        if (!this.isCurrentCycle(sessionId, state.lastEndedAt, generation))
+            return;
+        const idleMs = toIdleMs(idleSeconds);
+        if (idleMs === undefined)
+            return;
+        const delay = Math.max(0, state.lastEndedAt + idleMs - this.now());
+        const timer = setTimeout(() => {
+            this.timers.delete(sessionId);
+            void this.emitIfIdle(sessionId, state.lastEndedAt, generation);
+        }, delay);
+        timer.unref?.();
+        if (this.isCurrentCycle(sessionId, state.lastEndedAt, generation))
+            this.timers.set(sessionId, timer);
+        else
+            clearTimeout(timer);
+    }
+    async emitIfIdle(sessionId, lastEndedAt, generation) {
+        if (!this.isCurrentCycle(sessionId, lastEndedAt, generation))
+            return;
+        let session;
+        try {
+            session = await this.options.getSessionById(sessionId);
+        }
+        catch (error) {
+            this.warn(`Failed to load session ${sessionId} for idle check`, error);
+            this.recordActivity(sessionId, this.now());
+            return;
+        }
+        if (!this.isCurrentCycle(sessionId, lastEndedAt, generation))
+            return;
+        if (!session || session.deletedAt) {
+            this.clearSession(sessionId);
+            return;
+        }
+        if (!isSupportedSession(session))
+            return;
+        const idleMs = toIdleMs(await this.readIdleSeconds(session));
+        if (!this.isCurrentCycle(sessionId, lastEndedAt, generation))
+            return;
+        if (idleMs === undefined)
+            return;
+        const remaining = lastEndedAt + idleMs - this.now();
+        if (remaining > 0) {
+            this.scheduleSession(sessionId);
+            return;
+        }
+        let busy;
+        try {
+            busy = await this.options.isSessionBusy(sessionId);
+        }
+        catch (error) {
+            this.warn(`Failed to check whether session ${sessionId} is busy`, error);
+            this.recordActivity(sessionId, this.now());
+            return;
+        }
+        if (!this.isCurrentCycle(sessionId, lastEndedAt, generation))
+            return;
+        if (busy) {
+            // An active/queued task is not idle. Disarm this cycle and let its next
+            // terminal event start a fresh one; repeatedly rearming here would poll
+            // long-running sessions every 30 seconds.
+            this.clearTimers(sessionId);
+            return;
+        }
+        if (!session.selfAID) {
+            this.warn(`Skipping idle event for session ${sessionId}: session has no selfAID`);
+            this.clearSession(sessionId);
+            return;
+        }
+        const state = this.sessions.get(sessionId);
+        if (!state || state.emitted)
+            return;
+        state.emitted = true;
+        this.persistState();
+        this.options.eventBus.publish({
+            type: 'session:idle',
+            sessionId,
+            agentAid: session.selfAID,
+            channel: session.channelType || session.channel,
+            channelName: session.channel,
+            channelId: session.channelId,
+            chatType: session.chatType,
+            ...(session.threadId ? { threadId: session.threadId } : {}),
+            ...(session.metadata?.peerId || session.channelId ? { peerId: session.metadata?.peerId || session.channelId } : {}),
+            ...(typeof state.encrypted === 'boolean'
+                ? { encrypted: state.encrypted }
+                : typeof session.metadata?.replyContext?.metadata?.encrypted === 'boolean'
+                    ? { encrypted: session.metadata.replyContext.metadata.encrypted }
+                    : {}),
+            idleMs,
+            lastEndedAt,
+            timestamp: this.now(),
+            causation: createRootCausation(),
+        });
+    }
+    isCurrentCycle(sessionId, lastEndedAt, generation) {
+        const current = this.sessions.get(sessionId);
+        return this.active
+            && (this.generations.get(sessionId) ?? 0) === generation
+            && current?.lastEndedAt === lastEndedAt
+            && current !== undefined
+            && !current.emitted;
+    }
+    clearTimers(sessionId) {
+        const timer = this.timers.get(sessionId);
+        if (timer)
+            clearTimeout(timer);
+        this.timers.delete(sessionId);
+    }
+    clearAllTimers() {
+        for (const sessionId of this.timers.keys())
+            this.clearTimers(sessionId);
+    }
+    refreshSessionIdleTriggerIds() {
+        try {
+            for (const triggerId of this.options.getSessionIdleTriggerIds()) {
+                if (typeof triggerId === 'string' && triggerId.trim())
+                    this.knownSessionIdleTriggerIds.add(triggerId);
+            }
+        }
+        catch (error) {
+            this.warn('Failed to refresh session:idle trigger identities', error);
+        }
+    }
+    async readIdleSeconds(session) {
+        try {
+            return await this.options.getSessionIdleSeconds(session);
+        }
+        catch (error) {
+            this.warn(`Failed to read idle configuration for session ${session.id}`, error);
+            return undefined;
+        }
+    }
+    loadState() {
+        try {
+            if (!fs.existsSync(this.options.statePath))
+                return;
+            const parsed = JSON.parse(fs.readFileSync(this.options.statePath, 'utf8'));
+            if ((parsed.version !== 1 && parsed.version !== 2)
+                || !parsed.sessions || typeof parsed.sessions !== 'object' || Array.isArray(parsed.sessions)) {
+                this.warn(`Ignoring unsupported session idle state at ${this.options.statePath}`);
+                return;
+            }
+            for (const [sessionId, rawState] of Object.entries(parsed.sessions)) {
+                if (!sessionId || !rawState || typeof rawState !== 'object'
+                    || !Number.isFinite(rawState.lastEndedAt))
+                    continue;
+                const lastEndedAt = rawState.lastEndedAt;
+                const emitted = parsed.version === 2
+                    ? rawState.emitted === true
+                    : false;
+                this.sessions.set(sessionId, {
+                    lastEndedAt,
+                    emitted,
+                    ...(typeof rawState.encrypted === 'boolean' ? { encrypted: rawState.encrypted } : {}),
+                });
+            }
+        }
+        catch (error) {
+            this.warn(`Failed to load session idle state at ${this.options.statePath}`, error);
+        }
+    }
+    persistState() {
+        const sessions = {};
+        for (const [sessionId, state] of this.sessions) {
+            sessions[sessionId] = {
+                lastEndedAt: state.lastEndedAt,
+                emitted: state.emitted,
+                ...(typeof state.encrypted === 'boolean' ? { encrypted: state.encrypted } : {}),
+            };
+        }
+        try {
+            fs.mkdirSync(path.dirname(this.options.statePath), { recursive: true });
+            atomicWriteJson(this.options.statePath, { version: 2, sessions });
+        }
+        catch (error) {
+            this.warn(`Failed to persist session idle state at ${this.options.statePath}`, error);
+        }
+    }
+    warn(message, error) {
+        logger.warn(`[SessionIdleMonitor] ${message}${error === undefined ? '' : `: ${error instanceof Error ? error.message : String(error)}`}`);
+    }
+}
+function isSupportedSession(session) {
+    return session.chatType === 'group' || session.chatType === 'private';
+}
+function toIdleMs(seconds) {
+    if (seconds === undefined || !Number.isFinite(seconds) || seconds <= 0)
+        return undefined;
+    const idleMs = Math.max(MIN_SESSION_IDLE_SECONDS, seconds) * 1000;
+    return Number.isSafeInteger(idleMs) && idleMs > 0 ? idleMs : undefined;
+}
+function isTaskTerminalEvent(event) {
+    return event.type === 'task:completed' || event.type === 'task:error' || event.type === 'task:interrupted';
+}