@poolzin/pool-bot 2026.3.11 → 2026.3.14

package/dist/telegram/telegram-improvements.js

@@ -0,0 +1,220 @@
+/**
+ * Telegram Channel Improvements
+ *
+ * Implements OpenClaw improvements:
+ * - Streaming preview with sendMessageDraft for DMs
+ * - Reactions as system events (configurable)
+ * - Polling offset safety with validation
+ * - Webhook mode recovery with cert re-upload
+ * - Topic session isolation for DMs
+ *
+ * OpenClaw #32384, #30951
+ */
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("telegram-improvements");
+export const DEFAULT_TELEGRAM_STREAMING_CONFIG = {
+    enabledForDms: true,
+    enabledForGroups: false,
+    chunkDelayMs: 500,
+    minChunkSize: 50,
+    useDraftMethod: true,
+};
+/**
+ * Check if a chat is a DM (private chat)
+ */
+export function isPrivateChat(ctx) {
+    return ctx.chat?.type === "private";
+}
+/**
+ * Check if streaming should be enabled for this chat
+ */
+export function shouldEnableStreaming(ctx, config = DEFAULT_TELEGRAM_STREAMING_CONFIG) {
+    if (!config.enabledForDms && !config.enabledForGroups) {
+        return false;
+    }
+    if (isPrivateChat(ctx)) {
+        return config.enabledForDms;
+    }
+    return config.enabledForGroups;
+}
+/**
+ * Split message into chunks for streaming
+ */
+export function splitMessageForStreaming(text, config = DEFAULT_TELEGRAM_STREAMING_CONFIG) {
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        // Take up to minChunkSize characters
+        const chunkSize = Math.min(config.minChunkSize, remaining.length);
+        const chunk = remaining.slice(0, chunkSize);
+        chunks.push(chunk);
+        remaining = remaining.slice(chunkSize);
+    }
+    return chunks;
+}
+export const DEFAULT_STATUS_REACTION_CONFIG = {
+    enabled: true,
+    showInDms: false, // Don't spam DMs with reactions by default
+    showInGroups: true,
+    emojis: {
+        queued: ["👀", "👍"],
+        thinking: ["🤔", "🤓"],
+        tool: ["🔥", "⚡"],
+        done: ["👍", "🎉"],
+        error: ["😱", "😨"],
+    },
+    useSystemEvents: true, // Log as system events instead of visible reactions
+};
+/**
+ * Validate polling offset for safety
+ * OpenClaw #32384 - prevents offset corruption
+ */
+export function validatePollingOffset(params) {
+    const { currentOffset, lastUpdateId, maxAllowedGap } = params;
+    // No validation needed if no previous offset
+    if (currentOffset === null || currentOffset === 0) {
+        return { valid: true };
+    }
+    // Check for negative offset (corruption)
+    if (currentOffset < 0) {
+        log.warn("Polling offset is negative (corrupted), resetting to lastUpdateId", {
+            currentOffset,
+            lastUpdateId,
+        });
+        return {
+            valid: false,
+            reason: "Negative offset detected (corruption)",
+            suggestedOffset: lastUpdateId,
+        };
+    }
+    // Check for excessive gap (possible data loss)
+    if (lastUpdateId !== null) {
+        const gap = lastUpdateId - currentOffset;
+        if (gap > maxAllowedGap) {
+            log.warn("Polling offset gap too large, possible update loss", {
+                currentOffset,
+                lastUpdateId,
+                gap,
+                maxAllowedGap,
+            });
+            return {
+                valid: false,
+                reason: `Offset gap too large (${gap} > ${maxAllowedGap})`,
+                suggestedOffset: lastUpdateId,
+            };
+        }
+    }
+    return { valid: true };
+}
+export const DEFAULT_WEBHOOK_RECOVERY_CONFIG = {
+    enabled: true,
+    maxRetries: 3,
+    retryDelayMs: 5000,
+    reuploadCerts: true,
+    fallbackToPolling: true,
+};
+const webhookRecoveryStates = new Map();
+/**
+ * Get or create webhook recovery state for a bot
+ */
+export function getWebhookRecoveryState(botId) {
+    const existing = webhookRecoveryStates.get(botId);
+    if (existing) {
+        return existing;
+    }
+    const newState = {
+        attempt: 0,
+        recovering: false,
+        usePolling: false,
+    };
+    webhookRecoveryStates.set(botId, newState);
+    return newState;
+}
+/**
+ * Record webhook failure and check if recovery should be attempted
+ */
+export function recordWebhookFailure(params) {
+    const { botId, error, config } = params;
+    const state = getWebhookRecoveryState(botId);
+    state.attempt += 1;
+    state.lastError = error;
+    if (!config.enabled) {
+        return { canRecover: false, shouldFallback: false, retryAfterMs: 0 };
+    }
+    if (state.attempt > config.maxRetries) {
+        state.recovering = false;
+        if (config.fallbackToPolling) {
+            state.usePolling = true;
+            log.warn(`Webhook recovery failed after ${state.attempt} attempts, falling back to polling`, {
+                botId,
+            });
+            return { canRecover: false, shouldFallback: true, retryAfterMs: 0 };
+        }
+        return { canRecover: false, shouldFallback: false, retryAfterMs: 0 };
+    }
+    state.recovering = true;
+    const retryAfterMs = config.retryDelayMs * Math.pow(2, state.attempt - 1); // Exponential backoff
+    log.info(`Webhook failure recorded, attempting recovery in ${retryAfterMs}ms`, {
+        botId,
+        attempt: state.attempt,
+        error,
+    });
+    return { canRecover: true, shouldFallback: false, retryAfterMs };
+}
+/**
+ * Reset webhook recovery state after successful recovery
+ */
+export function resetWebhookRecoveryState(botId) {
+    const state = webhookRecoveryStates.get(botId);
+    if (state) {
+        state.attempt = 0;
+        state.lastError = undefined;
+        state.recovering = false;
+        state.usePolling = false;
+    }
+}
+export const DEFAULT_TOPIC_SESSION_CONFIG = {
+    enabledForDms: false, // DMs typically don't need topic isolation
+    enabledForGroups: true,
+    separator: ":",
+};
+/**
+ * Build session key with topic isolation
+ */
+export function buildTopicSessionKey(params) {
+    const { chatId, userId, threadId, topicId, config } = params;
+    const parts = [chatId];
+    if (topicId !== undefined && config.enabledForGroups) {
+        parts.push(config.separator, "topic", config.separator, topicId);
+    }
+    if (threadId !== undefined && config.enabledForGroups) {
+        parts.push(config.separator, "thread", config.separator, threadId);
+    }
+    if (userId !== undefined) {
+        parts.push(config.separator, "user", config.separator, userId);
+    }
+    return parts.join("");
+}
+/**
+ * Parse session key to extract topic/thread info
+ */
+export function parseTopicSessionKey(sessionKey) {
+    const parts = sessionKey.split(":");
+    const result = {
+        chatId: parts[0],
+    };
+    for (let i = 1; i < parts.length; i += 2) {
+        const key = parts[i];
+        const value = parts[i + 1];
+        if (key === "topic") {
+            result.topicId = value;
+        }
+        else if (key === "thread") {
+            result.threadId = value;
+        }
+        else if (key === "user") {
+            result.userId = value;
+        }
+    }
+    return result;
+}

package/dist/ui-plugins/ui-plugins-improvements.js

@@ -0,0 +1,191 @@
+/**
+ * UI/UX & Plugins Enhancements
+ *
+ * Implements OpenClaw improvements:
+ * - Cron editor with clone functionality
+ * - Sessions cleanup UI
+ * - Scoped plugin SDK imports
+ * - Hook session lifecycle (session_start/session_end)
+ * - HTTP route registration API
+ *
+ * OpenClaw #30951, #32384
+ */
+export const DEFAULT_CRON_EDITOR_CONFIG = {
+    enabled: true,
+    enableClone: true,
+    enableRichValidation: true,
+    validationRules: [
+        {
+            name: "no-past-schedule",
+            pattern: "^(\\*|[0-9]+)\\s+(\\*|[0-9]+)\\s+(\\*|[0-9]+)\\s+(\\*|[0-9]+)\\s+(\\*|[0-9]+)$",
+            errorMessage: "Invalid cron expression",
+            severity: "error",
+        },
+        {
+            name: "reasonable-frequency",
+            pattern: "^(\\*/[1-9][0-9]*|\\*|[0-9]+)\\s+.*$",
+            errorMessage: "Schedule runs too frequently (consider increasing interval)",
+            severity: "warning",
+        },
+    ],
+    defaultTimezone: "UTC",
+    showCronExpressions: true,
+    showNextRunTimes: true,
+    maxNextRunsToShow: 5,
+};
+export const DEFAULT_CRON_CLONE_CONFIG = {
+    nameSuffix: " (copy)",
+    enabledByDefault: false, // Start disabled to allow configuration
+    preserveSchedule: true,
+    preserveDelivery: true,
+    resetFailureCount: true,
+};
+/**
+ * Validate cron expression
+ */
+export function validateCronExpression(expression, config = DEFAULT_CRON_EDITOR_CONFIG) {
+    if (!config.enableRichValidation) {
+        // Basic validation only
+        const parts = expression.trim().split(/\s+/);
+        if (parts.length !== 5) {
+            return { valid: false, errors: ["Cron expression must have 5 parts"], warnings: [] };
+        }
+        return { valid: true, errors: [], warnings: [] };
+    }
+    const errors = [];
+    const warnings = [];
+    // Check against validation rules
+    for (const rule of config.validationRules) {
+        const regex = new RegExp(rule.pattern);
+        if (!regex.test(expression)) {
+            if (rule.severity === "error") {
+                errors.push(rule.errorMessage);
+            }
+            else if (rule.severity === "warning") {
+                warnings.push(rule.errorMessage);
+            }
+        }
+    }
+    if (errors.length === 0) {
+        return { valid: true, errors: [], warnings: [] };
+    }
+    return { valid: false, errors, warnings };
+}
+export const DEFAULT_SESSIONS_CLEANUP_CONFIG = {
+    enabled: true,
+    showSessionAge: true,
+    showSessionSize: true,
+    showLastActivity: true,
+    enableBulkDelete: true,
+    enableSearch: true,
+    enableExport: true,
+    autoCleanup: false, // Disabled by default for safety
+    autoCleanupAgeDays: 30,
+    confirmBeforeDelete: true,
+};
+export const DEFAULT_SCOPED_PLUGIN_SDK_CONFIG = {
+    enabled: true,
+    allowedModules: [
+        "@poolbot/plugin-sdk",
+        "@poolbot/plugin-sdk/tools",
+        "@poolbot/plugin-sdk/providers",
+        "@poolbot/plugin-sdk/hooks",
+    ],
+    blockedMethods: [
+        "require",
+        "eval",
+        "Function",
+        "vm.runInContext",
+        "child_process.exec",
+        "child_process.spawn",
+    ],
+    requireExplicitImports: true,
+    logViolations: true,
+};
+/**
+ * Validate plugin SDK import
+ */
+export function validatePluginSdkImport(params) {
+    const { importPath, config } = params;
+    if (!config.enabled) {
+        return { allowed: true };
+    }
+    // Check if module is allowed
+    if (!config.allowedModules.some((mod) => importPath.startsWith(mod))) {
+        return { allowed: false, reason: `Module "${importPath}" is not in allowed list` };
+    }
+    return { allowed: true };
+}
+export const DEFAULT_HOOK_SESSION_LIFECYCLE_CONFIG = {
+    enabled: true,
+    callSessionStart: true,
+    callSessionEnd: true,
+    includeSessionKey: true,
+    includeAgentMetadata: true,
+    hookTimeoutMs: 5000,
+    continueOnFailure: true,
+};
+export const DEFAULT_HTTP_ROUTE_REGISTRATION_CONFIG = {
+    enabled: true,
+    routePrefix: "/api/plugins",
+    requireAuth: true,
+    rateLimitPerMinute: 60,
+    maxRoutesPerPlugin: 10,
+    allowedMethods: ["GET", "POST"],
+    blockedPaths: ["/admin", "/config", "/auth", "/internal", "/gateway", "/system"],
+};
+const registeredRoutes = new Map();
+/**
+ * Register HTTP route for plugin
+ */
+export function registerHttpRoute(params) {
+    const { path, method, pluginId, handler, config } = params;
+    if (!config.enabled) {
+        return { success: false, reason: "HTTP route registration is disabled" };
+    }
+    // Check if path is blocked
+    if (config.blockedPaths.some((blocked) => path.startsWith(blocked))) {
+        return { success: false, reason: `Path "${path}" is blocked` };
+    }
+    // Check if method is allowed
+    if (!config.allowedMethods.includes(method.toUpperCase())) {
+        return { success: false, reason: `Method "${method}" is not allowed` };
+    }
+    // Check route count for plugin
+    const pluginRoutes = registeredRoutes.get(pluginId) ?? [];
+    if (pluginRoutes.length >= config.maxRoutesPerPlugin) {
+        return {
+            success: false,
+            reason: `Max routes (${config.maxRoutesPerPlugin}) exceeded for plugin`,
+        };
+    }
+    const fullPath = `${config.routePrefix}${path}`;
+    const route = {
+        path: fullPath,
+        method: method.toUpperCase(),
+        pluginId,
+        handler,
+        registeredAt: Date.now(),
+    };
+    pluginRoutes.push(route);
+    registeredRoutes.set(pluginId, pluginRoutes);
+    return { success: true, fullPath };
+}
+/**
+ * Get registered routes for plugin
+ */
+export function getPluginRoutes(pluginId) {
+    return registeredRoutes.get(pluginId) ?? [];
+}
+/**
+ * Unregister all routes for plugin
+ */
+export function unregisterPluginRoutes(pluginId) {
+    const routes = registeredRoutes.get(pluginId);
+    if (!routes) {
+        return 0;
+    }
+    const count = routes.length;
+    registeredRoutes.delete(pluginId);
+    return count;
+}