@poolzin/pool-bot 2026.3.25 → 2026.3.27

package/dist/agents/checkpoint-manager.js

@@ -1,290 +0,0 @@
-/**
- * Checkpoint Manager - Save/Restore state during long-running executions
- *
- * Features:
- * - Save execution state with metadata
- * - Restore from checkpoints
- * - Automatic cleanup of old checkpoints
- * - Atomic writes with rollback on failure
- * - Integrity verification via SHA256 hashes
- *
- * Based on Hermes Agent's checkpoint_manager.py
- */
-import { createHash } from "node:crypto";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { createSubsystemLogger } from "../logging/subsystem.js";
-const log = createSubsystemLogger("checkpoint-manager");
-const DEFAULT_CONFIG = {
-    checkpointDir: "./checkpoints",
-    maxCheckpointsPerSession: 10,
-    maxAgeHours: 24,
-    enableCompression: true,
-    compressionThreshold: 1024 * 1024, // 1MB
-};
-export class CheckpointManager {
-    config;
-    constructor(config) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Generate unique checkpoint ID
-     */
-    generateCheckpointId() {
-        const timestamp = Date.now();
-        const random = Math.random().toString(36).substring(2, 10);
-        return `chk_${timestamp}_${random}`;
-    }
-    /**
-     * Calculate SHA256 hash of data for integrity verification
-     */
-    calculateHash(data) {
-        return createHash("sha256").update(data).digest("hex");
-    }
-    /**
-     * Get checkpoint directory for a session
-     */
-    getSessionCheckpointDir(sessionId) {
-        const safeSessionId = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
-        return path.join(this.config.checkpointDir, safeSessionId);
-    }
-    /**
-     * Get checkpoint file path
-     */
-    getCheckpointFilePath(sessionId, checkpointId) {
-        return path.join(this.getSessionCheckpointDir(sessionId), `${checkpointId}.json`);
-    }
-    /**
-     * Save a checkpoint
-     */
-    async saveCheckpoint(sessionId, data, options) {
-        const checkpointId = this.generateCheckpointId();
-        const sessionDir = this.getSessionCheckpointDir(sessionId);
-        // Ensure directory exists
-        await fs.mkdir(sessionDir, { recursive: true });
-        // Serialize data
-        const serializedData = JSON.stringify(data, null, 2);
-        const sizeBytes = Buffer.byteLength(serializedData, "utf-8");
-        const hash = this.calculateHash(serializedData);
-        // Create metadata
-        const metadata = {
-            id: checkpointId,
-            sessionId,
-            name: options?.name || `checkpoint-${checkpointId.substring(0, 8)}`,
-            description: options?.description,
-            createdAt: Date.now(),
-            sizeBytes,
-            hash,
-            compression: "none",
-            tags: options?.tags,
-        };
-        // Write checkpoint atomically (write to temp file, then rename)
-        const tempPath = `${this.getCheckpointFilePath(sessionId, checkpointId)}.tmp`;
-        const finalPath = this.getCheckpointFilePath(sessionId, checkpointId);
-        try {
-            const store = {
-                metadata,
-                data,
-            };
-            await fs.writeFile(tempPath, JSON.stringify(store, null, 2), "utf-8");
-            await fs.rename(tempPath, finalPath);
-            log.debug(`Saved checkpoint ${checkpointId} for session ${sessionId} (${sizeBytes} bytes)`);
-            // Cleanup old checkpoints
-            await this.cleanupOldCheckpoints(sessionId);
-            return metadata;
-        }
-        catch (error) {
-            // Cleanup temp file on failure
-            try {
-                await fs.unlink(tempPath);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-            throw error;
-        }
-    }
-    /**
-     * Load a checkpoint by ID
-     */
-    async loadCheckpoint(sessionId, checkpointId) {
-        const checkpointPath = this.getCheckpointFilePath(sessionId, checkpointId);
-        try {
-            const content = await fs.readFile(checkpointPath, "utf-8");
-            const store = JSON.parse(content);
-            // Verify integrity
-            const serializedData = JSON.stringify(store.data, null, 2);
-            const calculatedHash = this.calculateHash(serializedData);
-            if (calculatedHash !== store.metadata.hash) {
-                log.warn(`Checkpoint ${checkpointId} integrity check failed`);
-                return null;
-            }
-            return store;
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return null;
-            }
-            throw error;
-        }
-    }
-    /**
-     * List all checkpoints for a session
-     */
-    async listCheckpoints(sessionId) {
-        const sessionDir = this.getSessionCheckpointDir(sessionId);
-        try {
-            const files = await fs.readdir(sessionDir);
-            const checkpoints = [];
-            for (const file of files) {
-                if (!file.endsWith(".json")) {
-                    continue;
-                }
-                const checkpointId = file.replace(".json", "");
-                const store = await this.loadCheckpoint(sessionId, checkpointId);
-                if (store) {
-                    checkpoints.push(store.metadata);
-                }
-            }
-            // Sort by creation time (newest first)
-            return checkpoints.sort((a, b) => b.createdAt - a.createdAt);
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return [];
-            }
-            throw error;
-        }
-    }
-    /**
-     * Delete a checkpoint
-     */
-    async deleteCheckpoint(sessionId, checkpointId) {
-        const checkpointPath = this.getCheckpointFilePath(sessionId, checkpointId);
-        try {
-            await fs.unlink(checkpointPath);
-            log.debug(`Deleted checkpoint ${checkpointId} for session ${sessionId}`);
-            return true;
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return false;
-            }
-            throw error;
-        }
-    }
-    /**
-     * Get the latest checkpoint for a session
-     */
-    async getLatestCheckpoint(sessionId) {
-        const checkpoints = await this.listCheckpoints(sessionId);
-        if (checkpoints.length === 0) {
-            return null;
-        }
-        const latest = checkpoints[0]; // Already sorted newest first
-        return this.loadCheckpoint(sessionId, latest.id);
-    }
-    /**
-     * Cleanup old checkpoints
-     * - Keep only maxCheckpointsPerSession
-     * - Remove checkpoints older than maxAgeHours
-     */
-    async cleanupOldCheckpoints(sessionId) {
-        const checkpoints = await this.listCheckpoints(sessionId);
-        const now = Date.now();
-        const maxAgeMs = this.config.maxAgeHours * 60 * 60 * 1000;
-        let deleted = 0;
-        for (let i = 0; i < checkpoints.length; i++) {
-            const checkpoint = checkpoints[i];
-            const age = now - checkpoint.createdAt;
-            const isTooOld = age > maxAgeMs;
-            const isBeyondMax = i >= this.config.maxCheckpointsPerSession;
-            if (isTooOld || isBeyondMax) {
-                await this.deleteCheckpoint(sessionId, checkpoint.id);
-                deleted++;
-            }
-        }
-        const kept = checkpoints.length - deleted;
-        if (deleted > 0) {
-            log.debug(`Cleaned up ${deleted} old checkpoints for session ${sessionId} (kept ${kept})`);
-        }
-        return { deleted, kept };
-    }
-    /**
-     * Cleanup all checkpoints for all sessions
-     */
-    async cleanupAllCheckpoints() {
-        let totalDeleted = 0;
-        let sessionsProcessed = 0;
-        try {
-            const sessionDirs = await fs.readdir(this.config.checkpointDir);
-            for (const sessionDir of sessionDirs) {
-                const fullPath = path.join(this.config.checkpointDir, sessionDir);
-                const stat = await fs.stat(fullPath);
-                if (stat.isDirectory()) {
-                    const sessionId = sessionDir;
-                    const result = await this.cleanupOldCheckpoints(sessionId);
-                    totalDeleted += result.deleted;
-                    sessionsProcessed++;
-                }
-            }
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                throw error;
-            }
-        }
-        log.debug(`Global checkpoint cleanup: deleted ${totalDeleted} from ${sessionsProcessed} sessions`);
-        return { totalDeleted, sessionsProcessed };
-    }
-    /**
-     * Get checkpoint statistics
-     */
-    async getStats() {
-        const stats = {
-            totalCheckpoints: 0,
-            totalSessions: 0,
-            totalSizeBytes: 0,
-            oldestCheckpoint: undefined,
-            newestCheckpoint: undefined,
-        };
-        try {
-            const sessionDirs = await fs.readdir(this.config.checkpointDir);
-            for (const sessionDir of sessionDirs) {
-                const fullPath = path.join(this.config.checkpointDir, sessionDir);
-                const stat = await fs.stat(fullPath);
-                if (stat.isDirectory()) {
-                    stats.totalSessions++;
-                    const checkpoints = await this.listCheckpoints(sessionDir);
-                    for (const checkpoint of checkpoints) {
-                        stats.totalCheckpoints++;
-                        stats.totalSizeBytes += checkpoint.sizeBytes;
-                        if (!stats.oldestCheckpoint || checkpoint.createdAt < stats.oldestCheckpoint) {
-                            stats.oldestCheckpoint = checkpoint.createdAt;
-                        }
-                        if (!stats.newestCheckpoint || checkpoint.createdAt > stats.newestCheckpoint) {
-                            stats.newestCheckpoint = checkpoint.createdAt;
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                throw error;
-            }
-        }
-        return stats;
-    }
-}
-// Export singleton instance for convenience
-let globalCheckpointManager;
-export function getCheckpointManager(config) {
-    if (!globalCheckpointManager) {
-        globalCheckpointManager = new CheckpointManager(config);
-    }
-    return globalCheckpointManager;
-}
-export function resetCheckpointManager() {
-    globalCheckpointManager = undefined;
-}

package/dist/agents/claude-cli-runner.js

@@ -1,3 +0,0 @@
-// Backwards-compatible entry point.
-// Implementation lives in `src/agents/cli-runner.ts` (so we can reuse the same runner for other CLIs).
-export { runClaudeCliAgent, runCliAgent } from "./cli-runner.js";

package/dist/agents/error-classifier.js

@@ -1,251 +0,0 @@
-/**
- * Error Classification System
- *
- * Provides comprehensive error classification for LLM/AI operations.
- * Detects specific error types like context overflow, rate limits, etc.
- */
-// OpenAI error patterns
-const OPENAI_PATTERNS = {
-    context_overflow: [
-        /context length exceeded/i,
-        /maximum context length/i,
-        /token limit exceeded/i,
-        /too many tokens/i,
-        /rate_limit_exceeded.*context/i,
-    ],
-    rate_limit: [/rate limit exceeded/i, /too many requests/i, /ratelimit/i],
-    authentication: [/invalid api key/i, /incorrect api key/i, /authentication/i, /unauthorized/i],
-    invalid_request: [/invalid_request_error/i, /bad request/i, /invalid parameter/i],
-};
-// Anthropic error patterns
-const ANTHROPIC_PATTERNS = {
-    context_overflow: [/context window exceeded/i, /maximum token count/i, /too many tokens/i],
-    rate_limit: [/rate limit/i, /too many requests/i],
-    authentication: [/invalid api key/i, /authentication failed/i],
-    authorization: [
-        /forbidden/i,
-        /access denied/i,
-        /unauthorized.*resource/i,
-        /insufficient.*permission/i,
-    ],
-};
-// Google/Gemini error patterns
-const GEMINI_PATTERNS = {
-    context_overflow: [/token limit exceeded/i, /maximum input size/i, /context too long/i],
-    rate_limit: [/rate limit exceeded/i, /quota exceeded/i, /too many requests/i],
-    quota_exceeded: [/quota exceeded/i, /billing limit/i, /project quota/i],
-};
-// Generic patterns
-const GENERIC_PATTERNS = {
-    context_overflow: [
-        /context.*overflow/i,
-        /context.*exceeded/i,
-        /token.*limit/i,
-        /maximum.*context/i,
-        /message too long/i,
-        /input too long/i,
-    ],
-    rate_limit: [/rate.?limit/i, /too many requests/i, /throttled/i, /429/i],
-    timeout: [/timeout/i, /timed out/i, /etimedout/i],
-    network_error: [/network error/i, /econnreset/i, /econnrefused/i, /enotfound/i, /network/i],
-    server_error: [/server error/i, /internal error/i, /500/i, /502/i, /503/i, /504/i],
-    compaction_failure: [/compaction failed/i, /summarization failed/i, /failed to compact/i],
-};
-/**
- * Classify an error based on message patterns
- */
-export function classifyError(error) {
-    if (!(error instanceof Error)) {
-        return {
-            type: "unknown",
-            retryable: false,
-            message: String(error),
-        };
-    }
-    const message = error.message.toLowerCase();
-    // Check context overflow first (highest priority for LLM errors)
-    for (const pattern of [
-        ...OPENAI_PATTERNS.context_overflow,
-        ...ANTHROPIC_PATTERNS.context_overflow,
-        ...GEMINI_PATTERNS.context_overflow,
-        ...GENERIC_PATTERNS.context_overflow,
-    ]) {
-        if (pattern.test(message)) {
-            return {
-                type: "context_overflow",
-                retryable: false,
-                message: error.message,
-            };
-        }
-    }
-    // Check quota exceeded (before rate limit to avoid false positives)
-    for (const pattern of GEMINI_PATTERNS.quota_exceeded) {
-        if (pattern.test(message)) {
-            return {
-                type: "quota_exceeded",
-                retryable: false,
-                message: error.message,
-            };
-        }
-    }
-    // Check rate limit
-    for (const pattern of [
-        ...OPENAI_PATTERNS.rate_limit,
-        ...ANTHROPIC_PATTERNS.rate_limit,
-        ...GEMINI_PATTERNS.rate_limit,
-        ...GENERIC_PATTERNS.rate_limit,
-    ]) {
-        if (pattern.test(message)) {
-            return {
-                type: "rate_limit",
-                retryable: true,
-                message: error.message,
-            };
-        }
-    }
-    // Check authentication
-    for (const pattern of [...OPENAI_PATTERNS.authentication, ...ANTHROPIC_PATTERNS.authentication]) {
-        if (pattern.test(message)) {
-            return {
-                type: "authentication",
-                retryable: false,
-                message: error.message,
-            };
-        }
-    }
-    // Check authorization (403-like errors)
-    for (const pattern of ANTHROPIC_PATTERNS.authorization) {
-        if (pattern.test(message)) {
-            return {
-                type: "authorization",
-                retryable: false,
-                message: error.message,
-            };
-        }
-    }
-    // Check timeout
-    for (const pattern of GENERIC_PATTERNS.timeout) {
-        if (pattern.test(message)) {
-            return {
-                type: "timeout",
-                retryable: true,
-                message: error.message,
-            };
-        }
-    }
-    // Check network errors
-    for (const pattern of GENERIC_PATTERNS.network_error) {
-        if (pattern.test(message)) {
-            return {
-                type: "network_error",
-                retryable: true,
-                message: error.message,
-            };
-        }
-    }
-    // Check server errors
-    for (const pattern of GENERIC_PATTERNS.server_error) {
-        if (pattern.test(message)) {
-            return {
-                type: "server_error",
-                retryable: true,
-                message: error.message,
-            };
-        }
-    }
-    // Check compaction failure
-    for (const pattern of GENERIC_PATTERNS.compaction_failure) {
-        if (pattern.test(message)) {
-            return {
-                type: "compaction_failure",
-                retryable: true,
-                message: error.message,
-            };
-        }
-    }
-    // Default to unknown
-    return {
-        type: "unknown",
-        retryable: false,
-        message: error.message,
-    };
-}
-/**
- * Check if error is a context overflow error
- */
-export function isContextOverflowError(error) {
-    const classification = classifyError(error);
-    return classification.type === "context_overflow";
-}
-/**
- * Check if error is a rate limit error
- */
-export function isRateLimitError(error) {
-    const classification = classifyError(error);
-    return classification.type === "rate_limit";
-}
-/**
- * Check if error is a compaction failure
- */
-export function isCompactionFailureError(error) {
-    const classification = classifyError(error);
-    return classification.type === "compaction_failure";
-}
-/**
- * Check if error is likely a context overflow (heuristic)
- */
-export function isLikelyContextOverflowError(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    const message = error.message.toLowerCase();
-    // Check for common indicators
-    const indicators = [
-        "context",
-        "token",
-        "length",
-        "exceeded",
-        "maximum",
-        "limit",
-        "too long",
-        "too many",
-    ];
-    const score = indicators.reduce((acc, indicator) => {
-        return acc + (message.includes(indicator) ? 1 : 0);
-    }, 0);
-    // If 3+ indicators present, likely context overflow
-    return score >= 3;
-}
-/**
- * Get retry delay for error type
- */
-export function getRetryDelayForError(error, attempt) {
-    const classification = classifyError(error);
-    switch (classification.type) {
-        case "rate_limit":
-            // Rate limits: start with 2s, double each attempt
-            return Math.min(2000 * 2 ** attempt, 60000);
-        case "timeout":
-        case "network_error":
-            // Network issues: start with 500ms
-            return Math.min(500 * 2 ** attempt, 30000);
-        case "server_error":
-            // Server errors: start with 1s
-            return Math.min(1000 * 2 ** attempt, 30000);
-        case "compaction_failure":
-            // Compaction: shorter delays
-            return Math.min(500 * 2 ** attempt, 5000);
-        default:
-            return 1000;
-    }
-}
-/**
- * Format error for logging (sanitized)
- */
-export function formatErrorForLogging(error) {
-    if (error instanceof Error) {
-        const classification = classifyError(error);
-        return `[${classification.type}] ${classification.message}`;
-    }
-    return `[unknown] ${String(error)}`;
-}

package/dist/agents/live-model-filter.js

@@ -1,84 +0,0 @@
-const ANTHROPIC_PREFIXES = [
-    "claude-opus-4-6",
-    "claude-sonnet-4-6",
-    "claude-opus-4-5",
-    "claude-sonnet-4-5",
-    "claude-haiku-4-5",
-];
-const OPENAI_MODELS = ["gpt-5.2", "gpt-5.0"];
-const CODEX_MODELS = [
-    "gpt-5.2",
-    "gpt-5.2-codex",
-    "gpt-5.3-codex",
-    "gpt-5.3-codex-spark",
-    "gpt-5.1-codex",
-    "gpt-5.1-codex-mini",
-    "gpt-5.1-codex-max",
-];
-const GOOGLE_PREFIXES = ["gemini-3"];
-const ZAI_PREFIXES = ["glm-5", "glm-4.7", "glm-4.7-flash", "glm-4.7-flashx"];
-const MINIMAX_PREFIXES = ["minimax-m2.1", "minimax-m2.5"];
-const XAI_PREFIXES = ["grok-4"];
-function matchesPrefix(id, prefixes) {
-    return prefixes.some((prefix) => id.startsWith(prefix));
-}
-function matchesExactOrPrefix(id, values) {
-    return values.some((value) => id === value || id.startsWith(value));
-}
-function matchesAny(id, values) {
-    return values.some((value) => id.includes(value));
-}
-export function isModernModelRef(ref) {
-    const provider = ref.provider?.trim().toLowerCase() ?? "";
-    const id = ref.id?.trim().toLowerCase() ?? "";
-    if (!provider || !id) {
-        return false;
-    }
-    if (provider === "anthropic") {
-        return matchesPrefix(id, ANTHROPIC_PREFIXES);
-    }
-    if (provider === "openai") {
-        return matchesExactOrPrefix(id, OPENAI_MODELS);
-    }
-    if (provider === "openai-codex") {
-        return matchesExactOrPrefix(id, CODEX_MODELS);
-    }
-    if (provider === "google" || provider === "google-gemini-cli") {
-        return matchesPrefix(id, GOOGLE_PREFIXES);
-    }
-    if (provider === "google-antigravity") {
-        return matchesPrefix(id, GOOGLE_PREFIXES) || matchesPrefix(id, ANTHROPIC_PREFIXES);
-    }
-    if (provider === "zai") {
-        return matchesPrefix(id, ZAI_PREFIXES);
-    }
-    if (provider === "minimax") {
-        return matchesPrefix(id, MINIMAX_PREFIXES);
-    }
-    if (provider === "xai") {
-        return matchesPrefix(id, XAI_PREFIXES);
-    }
-    if (provider === "opencode" && id.endsWith("-free")) {
-        return false;
-    }
-    if (provider === "opencode" && id === "alpha-glm-4.7") {
-        return false;
-    }
-    // Opencode MiniMax variants have been intermittently unstable in live runs;
-    // prefer the rest of the modern catalog for deterministic smoke coverage.
-    if (provider === "opencode" && matchesPrefix(id, MINIMAX_PREFIXES)) {
-        return false;
-    }
-    if (provider === "openrouter" || provider === "opencode") {
-        return matchesAny(id, [
-            ...ANTHROPIC_PREFIXES,
-            ...OPENAI_MODELS,
-            ...CODEX_MODELS,
-            ...GOOGLE_PREFIXES,
-            ...ZAI_PREFIXES,
-            ...MINIMAX_PREFIXES,
-            ...XAI_PREFIXES,
-        ]);
-    }
-    return false;
-}