439 lines
17 KiB
JavaScript
439 lines
17 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.XiaoYiRuntime = void 0;
|
|
exports.getXiaoYiRuntime = getXiaoYiRuntime;
|
|
exports.setXiaoYiRuntime = setXiaoYiRuntime;
|
|
const websocket_1 = require("./websocket");
|
|
/**
|
|
* Default timeout configuration
|
|
*/
|
|
const DEFAULT_TIMEOUT_CONFIG = {
|
|
enabled: true,
|
|
duration: 60000, // 60 seconds
|
|
message: "任务正在处理中，请稍后",
|
|
};
|
|
/**
|
|
* Runtime state for XiaoYi channel
|
|
* Manages single WebSocket connection (single account mode)
|
|
*/
|
|
class XiaoYiRuntime {
|
|
constructor() {
|
|
this.connection = null;
|
|
this.pluginRuntime = null; // Store PluginRuntime from OpenClaw
|
|
this.config = null;
|
|
this.sessionToTaskIdMap = new Map(); // Map sessionId to taskId
|
|
// Timeout management
|
|
this.sessionTimeoutMap = new Map();
|
|
this.sessionTimeoutSent = new Set();
|
|
this.timeoutConfig = DEFAULT_TIMEOUT_CONFIG;
|
|
// AbortController management for canceling agent runs
|
|
this.sessionAbortControllerMap = new Map();
|
|
// Track if a session has an active agent run (for concurrent request detection)
|
|
this.sessionActiveRunMap = new Map();
|
|
// Track session start time for timeout detection
|
|
this.sessionStartTimeMap = new Map();
|
|
// 1-hour task timeout mechanism
|
|
this.sessionTaskTimeoutMap = new Map();
|
|
this.sessionPushPendingMap = new Map();
|
|
this.taskTimeoutMs = 3600000; // Default 1 hour
|
|
this.instanceId = `runtime_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
|
|
console.log(`XiaoYi: Created new runtime instance: ${this.instanceId}`);
|
|
}
|
|
getInstanceId() {
|
|
return this.instanceId;
|
|
}
|
|
/**
|
|
* Set OpenClaw PluginRuntime (from api.runtime in register())
|
|
*/
|
|
setPluginRuntime(runtime) {
|
|
console.log(`XiaoYi: [${this.instanceId}] Setting PluginRuntime`);
|
|
this.pluginRuntime = runtime;
|
|
}
|
|
/**
|
|
* Get OpenClaw PluginRuntime
|
|
*/
|
|
getPluginRuntime() {
|
|
return this.pluginRuntime;
|
|
}
|
|
/**
|
|
* Start connection (single account mode)
|
|
*/
|
|
async start(config) {
|
|
if (this.connection) {
|
|
console.log("XiaoYi channel already connected");
|
|
return;
|
|
}
|
|
this.config = config;
|
|
const manager = new websocket_1.XiaoYiWebSocketManager(config);
|
|
// Setup basic event handlers (message handling is done in channel.ts)
|
|
manager.on("error", (error) => {
|
|
console.error("XiaoYi channel error:", error);
|
|
});
|
|
manager.on("disconnected", () => {
|
|
console.log("XiaoYi channel disconnected");
|
|
});
|
|
manager.on("authenticated", () => {
|
|
console.log("XiaoYi channel authenticated");
|
|
});
|
|
manager.on("maxReconnectAttemptsReached", (serverId) => {
|
|
console.error(`XiaoYi channel ${serverId} max reconnect attempts reached`);
|
|
// Check if the other server is still connected and ready
|
|
const otherServerId = serverId === 'server1' ? 'server2' : 'server1';
|
|
const serverStates = manager.getServerStates();
|
|
const otherServerState = otherServerId === 'server1' ? serverStates.server1 : serverStates.server2;
|
|
if (otherServerState?.connected && otherServerState?.ready) {
|
|
console.warn(`[${otherServerId}] is still connected and ready, continuing in single-server mode`);
|
|
console.warn(`System will continue running with ${otherServerId} only`);
|
|
// Don't stop, continue with the other server
|
|
return;
|
|
}
|
|
// Only stop when both servers have failed
|
|
console.error("Both servers have reached max reconnect attempts, stopping connection");
|
|
console.error(`Server1: ${serverStates.server1.connected ? 'connected' : 'disconnected'}, Server2: ${serverStates.server2.connected ? 'connected' : 'disconnected'}`);
|
|
this.stop();
|
|
});
|
|
// Connect
|
|
await manager.connect();
|
|
this.connection = manager;
|
|
console.log("XiaoYi channel started");
|
|
}
|
|
/**
|
|
* Stop connection
|
|
*/
|
|
stop() {
|
|
if (this.connection) {
|
|
this.connection.disconnect();
|
|
this.connection = null;
|
|
console.log("XiaoYi channel stopped");
|
|
}
|
|
// Clear session mappings
|
|
this.sessionToTaskIdMap.clear();
|
|
// Clear all timeouts
|
|
this.clearAllTimeouts();
|
|
// Clear all abort controllers
|
|
this.clearAllAbortControllers();
|
|
// Clear all task timeout state
|
|
for (const sessionId of this.sessionTaskTimeoutMap.keys()) {
|
|
this.clearTaskTimeoutState(sessionId);
|
|
}
|
|
}
|
|
/**
|
|
* Set timeout configuration
|
|
*/
|
|
setTimeoutConfig(config) {
|
|
this.timeoutConfig = { ...this.timeoutConfig, ...config };
|
|
console.log(`XiaoYi: Timeout config updated:`, this.timeoutConfig);
|
|
}
|
|
/**
|
|
* Get timeout configuration
|
|
*/
|
|
getTimeoutConfig() {
|
|
return { ...this.timeoutConfig };
|
|
}
|
|
/**
|
|
* Set timeout for a session
|
|
* @param sessionId - Session ID
|
|
* @param callback - Function to call when timeout occurs
|
|
* @returns The interval ID (for cancellation)
|
|
*
|
|
* IMPORTANT: This now uses setInterval instead of setTimeout
|
|
* - First trigger: after 60 seconds
|
|
* - Subsequent triggers: every 60 seconds after that
|
|
* - Cleared when: response received, session completed, or explicitly cleared
|
|
*/
|
|
setTimeoutForSession(sessionId, callback) {
|
|
if (!this.timeoutConfig.enabled) {
|
|
console.log(`[TIMEOUT] Timeout disabled, skipping for session ${sessionId}`);
|
|
return undefined;
|
|
}
|
|
// Clear existing timeout AND timeout flag if any (reuse session scenario)
|
|
const hadExistingTimeout = this.sessionTimeoutMap.has(sessionId);
|
|
const hadSentTimeout = this.sessionTimeoutSent.has(sessionId);
|
|
this.clearSessionTimeout(sessionId);
|
|
// Clear the timeout sent flag to allow this session to timeout again
|
|
if (hadSentTimeout) {
|
|
this.sessionTimeoutSent.delete(sessionId);
|
|
console.log(`[TIMEOUT] Previous timeout flag cleared for session ${sessionId} (session reuse)`);
|
|
}
|
|
// Use setInterval for periodic timeout triggers
|
|
// First trigger after duration, then every duration after that
|
|
const intervalId = setInterval(() => {
|
|
console.log(`[TIMEOUT] Timeout triggered for session ${sessionId} (will trigger again in ${this.timeoutConfig.duration}ms if still active)`);
|
|
this.sessionTimeoutSent.add(sessionId);
|
|
callback();
|
|
}, this.timeoutConfig.duration);
|
|
this.sessionTimeoutMap.set(sessionId, intervalId);
|
|
const logSuffix = hadExistingTimeout ? " (replacing existing interval)" : "";
|
|
console.log(`[TIMEOUT] ${this.timeoutConfig.duration}ms periodic timeout started for session ${sessionId}${logSuffix}`);
|
|
return intervalId;
|
|
}
|
|
/**
|
|
* Clear timeout interval for a session
|
|
* @param sessionId - Session ID
|
|
*/
|
|
clearSessionTimeout(sessionId) {
|
|
const intervalId = this.sessionTimeoutMap.get(sessionId);
|
|
if (intervalId) {
|
|
clearInterval(intervalId);
|
|
this.sessionTimeoutMap.delete(sessionId);
|
|
console.log(`[TIMEOUT] Timeout interval cleared for session ${sessionId}`);
|
|
}
|
|
}
|
|
/**
|
|
* Check if timeout has been sent for a session
|
|
* @param sessionId - Session ID
|
|
*/
|
|
isSessionTimeout(sessionId) {
|
|
return this.sessionTimeoutSent.has(sessionId);
|
|
}
|
|
/**
|
|
* Mark session as completed (clear timeout and timeout flag)
|
|
* @param sessionId - Session ID
|
|
*/
|
|
markSessionCompleted(sessionId) {
|
|
this.clearSessionTimeout(sessionId);
|
|
this.sessionTimeoutSent.delete(sessionId);
|
|
console.log(`[TIMEOUT] Session ${sessionId} marked as completed`);
|
|
}
|
|
/**
|
|
* Clear all timeout intervals
|
|
*/
|
|
clearAllTimeouts() {
|
|
for (const [sessionId, intervalId] of this.sessionTimeoutMap.entries()) {
|
|
clearInterval(intervalId);
|
|
}
|
|
this.sessionTimeoutMap.clear();
|
|
this.sessionTimeoutSent.clear();
|
|
console.log("[TIMEOUT] All timeout intervals cleared");
|
|
}
|
|
/**
|
|
* Get WebSocket manager
|
|
*/
|
|
getConnection() {
|
|
return this.connection;
|
|
}
|
|
/**
|
|
* Check if connected
|
|
*/
|
|
isConnected() {
|
|
return this.connection ? this.connection.isReady() : false;
|
|
}
|
|
/**
|
|
* Get configuration
|
|
*/
|
|
getConfig() {
|
|
return this.config;
|
|
}
|
|
/**
|
|
* Set taskId for a session
|
|
*/
|
|
setTaskIdForSession(sessionId, taskId) {
|
|
this.sessionToTaskIdMap.set(sessionId, taskId);
|
|
}
|
|
/**
|
|
* Get taskId for a session
|
|
*/
|
|
getTaskIdForSession(sessionId) {
|
|
return this.sessionToTaskIdMap.get(sessionId);
|
|
}
|
|
/**
|
|
* Clear taskId for a session
|
|
*/
|
|
clearTaskIdForSession(sessionId) {
|
|
this.sessionToTaskIdMap.delete(sessionId);
|
|
}
|
|
/**
|
|
* Create and register an AbortController for a session
|
|
* @param sessionId - Session ID
|
|
* @returns The AbortController and its signal, or null if session is busy
|
|
*/
|
|
createAbortControllerForSession(sessionId) {
|
|
// Check if there's an active agent run for this session
|
|
if (this.sessionActiveRunMap.get(sessionId)) {
|
|
console.log(`[CONCURRENT] Session ${sessionId} has an active agent run, cannot create new AbortController`);
|
|
return null;
|
|
}
|
|
const controller = new AbortController();
|
|
this.sessionAbortControllerMap.set(sessionId, controller);
|
|
this.sessionActiveRunMap.set(sessionId, true);
|
|
this.sessionStartTimeMap.set(sessionId, Date.now());
|
|
console.log(`[ABORT] Created AbortController for session ${sessionId}`);
|
|
return { controller, signal: controller.signal };
|
|
}
|
|
/**
|
|
* Check if a session has an active agent run
|
|
* If session is active but stale (超过 SESSION_STALE_TIMEOUT_MS), automatically clean up
|
|
* @param sessionId - Session ID
|
|
* @returns true if session is busy
|
|
*/
|
|
isSessionActive(sessionId) {
|
|
const isActive = this.sessionActiveRunMap.get(sessionId) || false;
|
|
if (isActive) {
|
|
// Check if the session has been active for too long
|
|
const startTime = this.sessionStartTimeMap.get(sessionId);
|
|
if (startTime) {
|
|
const elapsed = Date.now() - startTime;
|
|
if (elapsed > XiaoYiRuntime.SESSION_STALE_TIMEOUT_MS) {
|
|
// Session is stale, auto-cleanup and return false
|
|
console.log(`[CONCURRENT] Session ${sessionId} is stale (active for ${elapsed}ms), auto-cleaning`);
|
|
this.clearAbortControllerForSession(sessionId);
|
|
this.clearTaskIdForSession(sessionId);
|
|
this.clearSessionTimeout(sessionId);
|
|
this.sessionStartTimeMap.delete(sessionId);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return isActive;
|
|
}
|
|
/**
|
|
* Abort a session's agent run
|
|
* @param sessionId - Session ID
|
|
* @returns true if a controller was found and aborted, false otherwise
|
|
*/
|
|
abortSession(sessionId) {
|
|
const controller = this.sessionAbortControllerMap.get(sessionId);
|
|
if (controller) {
|
|
console.log(`[ABORT] Aborting session ${sessionId}`);
|
|
controller.abort();
|
|
this.sessionAbortControllerMap.delete(sessionId);
|
|
return true;
|
|
}
|
|
console.log(`[ABORT] No AbortController found for session ${sessionId}`);
|
|
return false;
|
|
}
|
|
/**
|
|
* Check if a session has been aborted
|
|
* @param sessionId - Session ID
|
|
* @returns true if the session's abort signal was triggered
|
|
*/
|
|
isSessionAborted(sessionId) {
|
|
const controller = this.sessionAbortControllerMap.get(sessionId);
|
|
return controller ? controller.signal.aborted : false;
|
|
}
|
|
/**
|
|
* Clear the AbortController for a session (call when agent completes successfully)
|
|
* @param sessionId - Session ID
|
|
*/
|
|
clearAbortControllerForSession(sessionId) {
|
|
const controller = this.sessionAbortControllerMap.get(sessionId);
|
|
if (controller) {
|
|
this.sessionAbortControllerMap.delete(sessionId);
|
|
console.log(`[ABORT] Cleared AbortController for session ${sessionId}`);
|
|
}
|
|
// Also clear the active run flag
|
|
this.sessionActiveRunMap.delete(sessionId);
|
|
// Clear the session start time
|
|
this.sessionStartTimeMap.delete(sessionId);
|
|
console.log(`[CONCURRENT] Session ${sessionId} marked as inactive`);
|
|
}
|
|
/**
|
|
* Clear all AbortControllers
|
|
*/
|
|
clearAllAbortControllers() {
|
|
this.sessionAbortControllerMap.clear();
|
|
console.log("[ABORT] All AbortControllers cleared");
|
|
}
|
|
// ==================== PUSH STATE MANAGEMENT HELPERS ====================
|
|
/**
|
|
* Generate a composite key for session+task combination
|
|
* This ensures each task has its own push state, even within the same session
|
|
*/
|
|
getPushStateKey(sessionId, taskId) {
|
|
return `${sessionId}:${taskId}`;
|
|
}
|
|
// ==================== END PUSH STATE MANAGEMENT HELPERS ====================
|
|
// ==================== 1-HOUR TASK TIMEOUT METHODS ====================
|
|
/**
|
|
* Set task timeout time (from configuration)
|
|
*/
|
|
setTaskTimeout(timeoutMs) {
|
|
this.taskTimeoutMs = timeoutMs;
|
|
console.log(`[TASK TIMEOUT] Task timeout set to ${timeoutMs}ms`);
|
|
}
|
|
/**
|
|
* Set a 1-hour task timeout timer for a session
|
|
* @returns timeout ID
|
|
*/
|
|
setTaskTimeoutForSession(sessionId, taskId, callback) {
|
|
this.clearTaskTimeoutForSession(sessionId);
|
|
const timeoutId = setTimeout(() => {
|
|
console.log(`[TASK TIMEOUT] ${this.taskTimeoutMs}ms timeout triggered for session ${sessionId}, task ${taskId}`);
|
|
callback(sessionId, taskId);
|
|
}, this.taskTimeoutMs);
|
|
this.sessionTaskTimeoutMap.set(sessionId, timeoutId);
|
|
console.log(`[TASK TIMEOUT] ${this.taskTimeoutMs}ms task timeout started for session ${sessionId}`);
|
|
return timeoutId;
|
|
}
|
|
/**
|
|
* Clear the task timeout timer for a session
|
|
*/
|
|
clearTaskTimeoutForSession(sessionId) {
|
|
const timeoutId = this.sessionTaskTimeoutMap.get(sessionId);
|
|
if (timeoutId) {
|
|
clearTimeout(timeoutId);
|
|
this.sessionTaskTimeoutMap.delete(sessionId);
|
|
console.log(`[TASK TIMEOUT] Timeout cleared for session ${sessionId}`);
|
|
}
|
|
}
|
|
/**
|
|
* Check if session+task is waiting for push notification
|
|
* @param sessionId - Session ID
|
|
* @param taskId - Task ID (optional, for per-task tracking)
|
|
*/
|
|
isSessionWaitingForPush(sessionId, taskId) {
|
|
const key = taskId ? this.getPushStateKey(sessionId, taskId) : sessionId;
|
|
return this.sessionPushPendingMap.get(key) === true;
|
|
}
|
|
/**
|
|
* Mark session+task as waiting for push notification
|
|
* @param sessionId - Session ID
|
|
* @param taskId - Task ID (optional, for per-task tracking)
|
|
*/
|
|
markSessionWaitingForPush(sessionId, taskId) {
|
|
const key = taskId ? this.getPushStateKey(sessionId, taskId) : sessionId;
|
|
this.sessionPushPendingMap.set(key, true);
|
|
const taskInfo = taskId ? `, task ${taskId}` : '';
|
|
console.log(`[PUSH] Session ${sessionId}${taskInfo} marked as waiting for push`);
|
|
}
|
|
/**
|
|
* Clear the waiting push state for a session+task
|
|
* @param sessionId - Session ID
|
|
* @param taskId - Task ID (optional, for per-task tracking)
|
|
*/
|
|
clearSessionWaitingForPush(sessionId, taskId) {
|
|
const key = taskId ? this.getPushStateKey(sessionId, taskId) : sessionId;
|
|
this.sessionPushPendingMap.delete(key);
|
|
const taskInfo = taskId ? `, task ${taskId}` : '';
|
|
console.log(`[PUSH] Session ${sessionId}${taskInfo} cleared from waiting for push`);
|
|
}
|
|
/**
|
|
* Clear all task timeout related state for a session
|
|
*/
|
|
clearTaskTimeoutState(sessionId) {
|
|
this.clearTaskTimeoutForSession(sessionId);
|
|
this.clearSessionWaitingForPush(sessionId);
|
|
console.log(`[TASK TIMEOUT] All timeout state cleared for session ${sessionId}`);
|
|
}
|
|
}
|
|
exports.XiaoYiRuntime = XiaoYiRuntime;
|
|
// Maximum time a session can be active before we consider it stale (5 minutes)
|
|
XiaoYiRuntime.SESSION_STALE_TIMEOUT_MS = 5 * 60 * 1000;
|
|
// Global runtime instance - use global object to survive module reloads
|
|
// CRITICAL: Use string key instead of Symbol to ensure consistency across module reloads
|
|
const GLOBAL_KEY = '__xiaoyi_runtime_instance__';
|
|
function getXiaoYiRuntime() {
|
|
const g = global;
|
|
if (!g[GLOBAL_KEY]) {
|
|
console.log("XiaoYi: Creating NEW runtime instance (global storage)");
|
|
g[GLOBAL_KEY] = new XiaoYiRuntime();
|
|
}
|
|
else {
|
|
console.log(`XiaoYi: Reusing EXISTING runtime instance: ${g[GLOBAL_KEY].getInstanceId()}`);
|
|
}
|
|
return g[GLOBAL_KEY];
|
|
}
|
|
function setXiaoYiRuntime(runtime) {
|
|
getXiaoYiRuntime().setPluginRuntime(runtime);
|
|
}
|