@poolzin/pool-bot 2026.3.26 → 2026.3.28

package/dist/discord/voice-message.js

@@ -1,254 +0,0 @@
-/**
- * Discord Voice Message Support
- *
- * Implements sending voice messages via Discord's API.
- * Voice messages require:
- * - OGG/Opus format audio
- * - Waveform data (base64 encoded, up to 256 samples, 0-255 values)
- * - Duration in seconds
- * - Message flag 8192 (IS_VOICE_MESSAGE)
- * - No other content (text, embeds, etc.)
- */
-import { execFile } from "node:child_process";
-import crypto from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { promisify } from "node:util";
-import { resolvePreferredPoolbotTmpDir } from "../infra/tmp-poolbot-dir.js";
-const execFileAsync = promisify(execFile);
-const DISCORD_VOICE_MESSAGE_FLAG = 1 << 13;
-const SUPPRESS_NOTIFICATIONS_FLAG = 1 << 12;
-const WAVEFORM_SAMPLES = 256;
-/**
- * Get audio duration using ffprobe
- */
-export async function getAudioDuration(filePath) {
-    try {
-        const { stdout } = await execFileAsync("ffprobe", [
-            "-v",
-            "error",
-            "-show_entries",
-            "format=duration",
-            "-of",
-            "csv=p=0",
-            filePath,
-        ]);
-        const duration = parseFloat(stdout.trim());
-        if (isNaN(duration)) {
-            throw new Error("Could not parse duration");
-        }
-        return Math.round(duration * 100) / 100; // Round to 2 decimal places
-    }
-    catch (err) {
-        const errMessage = err instanceof Error ? err.message : String(err);
-        throw new Error(`Failed to get audio duration: ${errMessage}`, { cause: err });
-    }
-}
-/**
- * Generate waveform data from audio file using ffmpeg
- * Returns base64 encoded byte array of amplitude samples (0-255)
- */
-export async function generateWaveform(filePath) {
-    try {
-        // Extract raw PCM and sample amplitude values
-        return await generateWaveformFromPcm(filePath);
-    }
-    catch {
-        // If PCM extraction fails, generate a placeholder waveform
-        return generatePlaceholderWaveform();
-    }
-}
-/**
- * Generate waveform by extracting raw PCM data and sampling amplitudes
- */
-async function generateWaveformFromPcm(filePath) {
-    const tempDir = resolvePreferredPoolbotTmpDir();
-    const tempPcm = path.join(tempDir, `waveform-${crypto.randomUUID()}.raw`);
-    try {
-        // Convert to raw 16-bit signed PCM, mono, 8kHz
-        await execFileAsync("ffmpeg", [
-            "-y",
-            "-i",
-            filePath,
-            "-f",
-            "s16le",
-            "-acodec",
-            "pcm_s16le",
-            "-ac",
-            "1",
-            "-ar",
-            "8000",
-            tempPcm,
-        ]);
-        const pcmData = await fs.readFile(tempPcm);
-        const samples = new Int16Array(pcmData.buffer, pcmData.byteOffset, pcmData.byteLength / 2);
-        // Sample the PCM data to get WAVEFORM_SAMPLES points
-        const step = Math.max(1, Math.floor(samples.length / WAVEFORM_SAMPLES));
-        const waveform = [];
-        for (let i = 0; i < WAVEFORM_SAMPLES && i * step < samples.length; i++) {
-            // Get average absolute amplitude for this segment
-            let sum = 0;
-            let count = 0;
-            for (let j = 0; j < step && i * step + j < samples.length; j++) {
-                sum += Math.abs(samples[i * step + j]);
-                count++;
-            }
-            const avg = count > 0 ? sum / count : 0;
-            // Normalize to 0-255 (16-bit signed max is 32767)
-            const normalized = Math.min(255, Math.round((avg / 32767) * 255));
-            waveform.push(normalized);
-        }
-        // Pad with zeros if we don't have enough samples
-        while (waveform.length < WAVEFORM_SAMPLES) {
-            waveform.push(0);
-        }
-        return Buffer.from(waveform).toString("base64");
-    }
-    finally {
-        // Clean up temp file
-        try {
-            await fs.unlink(tempPcm);
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    }
-}
-/**
- * Generate a placeholder waveform (for when audio processing fails)
- */
-function generatePlaceholderWaveform() {
-    // Generate a simple sine-wave-like pattern
-    const waveform = [];
-    for (let i = 0; i < WAVEFORM_SAMPLES; i++) {
-        const value = Math.round(128 + 64 * Math.sin((i / WAVEFORM_SAMPLES) * Math.PI * 8));
-        waveform.push(Math.min(255, Math.max(0, value)));
-    }
-    return Buffer.from(waveform).toString("base64");
-}
-/**
- * Convert audio file to OGG/Opus format if needed
- * Returns path to the OGG file (may be same as input if already OGG/Opus)
- */
-export async function ensureOggOpus(filePath) {
-    const trimmed = filePath.trim();
-    // Defense-in-depth: callers should never hand ffmpeg/ffprobe a URL/protocol path.
-    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) {
-        throw new Error(`Voice message conversion requires a local file path; received a URL/protocol source: ${trimmed}`);
-    }
-    const ext = path.extname(filePath).toLowerCase();
-    // Check if already OGG
-    if (ext === ".ogg") {
-        // Verify it's Opus codec, not Vorbis (Vorbis won't play on mobile)
-        try {
-            const { stdout } = await execFileAsync("ffprobe", [
-                "-v",
-                "error",
-                "-select_streams",
-                "a:0",
-                "-show_entries",
-                "stream=codec_name",
-                "-of",
-                "csv=p=0",
-                filePath,
-            ]);
-            if (stdout.trim().toLowerCase() === "opus") {
-                return { path: filePath, cleanup: false };
-            }
-        }
-        catch {
-            // If probe fails, convert anyway
-        }
-    }
-    // Convert to OGG/Opus
-    const tempDir = resolvePreferredPoolbotTmpDir();
-    const outputPath = path.join(tempDir, `voice-${crypto.randomUUID()}.ogg`);
-    await execFileAsync("ffmpeg", [
-        "-y",
-        "-i",
-        filePath,
-        "-c:a",
-        "libopus",
-        "-b:a",
-        "64k",
-        outputPath,
-    ]);
-    return { path: outputPath, cleanup: true };
-}
-/**
- * Get voice message metadata (duration and waveform)
- */
-export async function getVoiceMessageMetadata(filePath) {
-    const [durationSecs, waveform] = await Promise.all([
-        getAudioDuration(filePath),
-        generateWaveform(filePath),
-    ]);
-    return { durationSecs, waveform };
-}
-/**
- * Send a voice message to Discord
- *
- * This follows Discord's voice message protocol:
- * 1. Request upload URL from Discord
- * 2. Upload the OGG file to the provided URL
- * 3. Send the message with flag 8192 and attachment metadata
- */
-export async function sendDiscordVoiceMessage(rest, channelId, audioBuffer, metadata, replyTo, request, silent) {
-    const filename = "voice-message.ogg";
-    const fileSize = audioBuffer.byteLength;
-    // Step 1: Request upload URL from Discord
-    const uploadUrlResponse = await request(() => rest.post(`/channels/${channelId}/attachments`, {
-        body: {
-            files: [
-                {
-                    filename,
-                    file_size: fileSize,
-                    id: "0",
-                },
-            ],
-        },
-    }), "voice-upload-url");
-    if (!uploadUrlResponse.attachments?.[0]) {
-        throw new Error("Failed to get upload URL for voice message");
-    }
-    const { upload_url, upload_filename } = uploadUrlResponse.attachments[0];
-    // Step 2: Upload the file to Discord's CDN
-    // Note: Not wrapped in retry runner - upload URLs are single-use and CDN behavior differs
-    const uploadResponse = await fetch(upload_url, {
-        method: "PUT",
-        headers: {
-            "Content-Type": "audio/ogg",
-        },
-        body: new Uint8Array(audioBuffer),
-    });
-    if (!uploadResponse.ok) {
-        throw new Error(`Failed to upload voice message: ${uploadResponse.status}`);
-    }
-    // Step 3: Send the message with voice message flag and metadata
-    const flags = silent
-        ? DISCORD_VOICE_MESSAGE_FLAG | SUPPRESS_NOTIFICATIONS_FLAG
-        : DISCORD_VOICE_MESSAGE_FLAG;
-    const messagePayload = {
-        flags,
-        attachments: [
-            {
-                id: "0",
-                filename,
-                uploaded_filename: upload_filename,
-                duration_secs: metadata.durationSecs,
-                waveform: metadata.waveform,
-            },
-        ],
-    };
-    // Note: Voice messages cannot have content, but can have message_reference for replies
-    if (replyTo) {
-        messagePayload.message_reference = {
-            message_id: replyTo,
-            fail_if_not_exists: false,
-        };
-    }
-    const res = (await request(() => rest.post(`/channels/${channelId}/messages`, {
-        body: messagePayload,
-    }), "voice-message"));
-    return res;
-}

package/dist/entry.js

@@ -1,136 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from "node:child_process";
-import path from "node:path";
-import process from "node:process";
-import { applyCliProfileEnv, parseCliProfileArgs } from "./cli/profile.js";
-import { isTruthyEnvValue, normalizeEnv } from "./infra/env.js";
-import { installProcessWarningFilter } from "./infra/warnings.js";
-import { attachChildProcessBridge } from "./process/child-process-bridge.js";
-process.title = "poolbot";
-installProcessWarningFilter();
-normalizeEnv();
-if (process.argv.includes("--no-color")) {
-    process.env.NO_COLOR = "1";
-    process.env.FORCE_COLOR = "0";
-}
-const EXPERIMENTAL_WARNING_FLAG = "--disable-warning=ExperimentalWarning";
-function hasExperimentalWarningSuppressed() {
-    const nodeOptions = process.env.NODE_OPTIONS ?? "";
-    if (nodeOptions.includes(EXPERIMENTAL_WARNING_FLAG) || nodeOptions.includes("--no-warnings"))
-        return true;
-    for (const arg of process.execArgv) {
-        if (arg === EXPERIMENTAL_WARNING_FLAG || arg === "--no-warnings")
-            return true;
-    }
-    return false;
-}
-function ensureExperimentalWarningSuppressed() {
-    if (isTruthyEnvValue(process.env.POOLBOT_NO_RESPAWN) ||
-        isTruthyEnvValue(process.env.CLAWDBOT_NO_RESPAWN))
-        return false;
-    if (isTruthyEnvValue(process.env.POOLBOT_NODE_OPTIONS_READY) ||
-        isTruthyEnvValue(process.env.CLAWDBOT_NODE_OPTIONS_READY))
-        return false;
-    if (hasExperimentalWarningSuppressed())
-        return false;
-    // Respawn guard (and keep recursion bounded if something goes wrong).
-    process.env.POOLBOT_NODE_OPTIONS_READY = "1";
-    process.env.CLAWDBOT_NODE_OPTIONS_READY = "1";
-    // Pass flag as a Node CLI option, not via NODE_OPTIONS (--disable-warning is disallowed in NODE_OPTIONS).
-    const child = spawn(process.execPath, [EXPERIMENTAL_WARNING_FLAG, ...process.execArgv, ...process.argv.slice(1)], {
-        stdio: "inherit",
-        env: process.env,
-    });
-    attachChildProcessBridge(child);
-    child.once("exit", (code, signal) => {
-        if (signal) {
-            process.exitCode = 1;
-            return;
-        }
-        process.exit(code ?? 1);
-    });
-    child.once("error", (error) => {
-        console.error("[poolbot] Failed to respawn CLI:", error instanceof Error ? (error.stack ?? error.message) : error);
-        process.exit(1);
-    });
-    // Parent must not continue running the CLI.
-    return true;
-}
-function normalizeWindowsArgv(argv) {
-    if (process.platform !== "win32")
-        return argv;
-    if (argv.length < 2)
-        return argv;
-    const stripControlChars = (value) => {
-        let out = "";
-        for (let i = 0; i < value.length; i += 1) {
-            const code = value.charCodeAt(i);
-            if (code >= 32 && code !== 127) {
-                out += value[i];
-            }
-        }
-        return out;
-    };
-    const normalizeArg = (value) => stripControlChars(value)
-        .replace(/^['"]+|['"]+$/g, "")
-        .trim();
-    const normalizeCandidate = (value) => normalizeArg(value).replace(/^\\\\\\?\\/, "");
-    const execPath = normalizeCandidate(process.execPath);
-    const execPathLower = execPath.toLowerCase();
-    const execBase = path.basename(execPath).toLowerCase();
-    const isExecPath = (value) => {
-        if (!value)
-            return false;
-        const lower = normalizeCandidate(value).toLowerCase();
-        return (lower === execPathLower ||
-            path.basename(lower) === execBase ||
-            lower.endsWith("\\node.exe") ||
-            lower.endsWith("/node.exe") ||
-            lower.includes("node.exe"));
-    };
-    const next = [...argv];
-    for (let i = 1; i <= 3 && i < next.length;) {
-        if (isExecPath(next[i])) {
-            next.splice(i, 1);
-            continue;
-        }
-        i += 1;
-    }
-    const filtered = next.filter((arg, index) => index === 0 || !isExecPath(arg));
-    if (filtered.length < 3)
-        return filtered;
-    const cleaned = [...filtered];
-    for (let i = 2; i < cleaned.length;) {
-        const arg = cleaned[i];
-        if (!arg || arg.startsWith("-")) {
-            i += 1;
-            continue;
-        }
-        if (isExecPath(arg)) {
-            cleaned.splice(i, 1);
-            continue;
-        }
-        break;
-    }
-    return cleaned;
-}
-process.argv = normalizeWindowsArgv(process.argv);
-if (!ensureExperimentalWarningSuppressed()) {
-    const parsed = parseCliProfileArgs(process.argv);
-    if (!parsed.ok) {
-        // Keep it simple; Commander will handle rich help/errors after we strip flags.
-        console.error(`[poolbot] ${parsed.error}`);
-        process.exit(2);
-    }
-    if (parsed.profile) {
-        applyCliProfileEnv({ profile: parsed.profile });
-        // Keep Commander and ad-hoc argv checks consistent.
-        process.argv = parsed.argv;
-    }
-    import("./cli/run-main.js")
-        .then(({ runCli }) => runCli(process.argv))
-        .catch((error) => {
-        console.error("[poolbot] Failed to start CLI:", error instanceof Error ? (error.stack ?? error.message) : error);
-        process.exitCode = 1;
-    });
-}

package/dist/extensionAPI.js

@@ -1,8 +0,0 @@
-export { resolveAgentDir, resolveAgentWorkspaceDir } from "./agents/agent-scope.js";
-export { DEFAULT_MODEL, DEFAULT_PROVIDER } from "./agents/defaults.js";
-export { resolveAgentIdentity } from "./agents/identity.js";
-export { resolveThinkingDefault } from "./agents/model-selection.js";
-export { runEmbeddedPiAgent } from "./agents/pi-embedded.js";
-export { resolveAgentTimeoutMs } from "./agents/timeout.js";
-export { ensureAgentWorkspace } from "./agents/workspace.js";
-export { resolveStorePath, loadSessionStore, saveSessionStore, resolveSessionFilePath, } from "./config/sessions.js";

package/dist/gateway/agent-event-assistant-text.js

@@ -1,5 +0,0 @@
-export function resolveAssistantStreamDeltaText(evt) {
-    const delta = evt.data.delta;
-    const text = evt.data.text;
-    return typeof delta === "string" ? delta : typeof text === "string" ? text : "";
-}

package/dist/gateway/agent-prompt.js

@@ -1,33 +0,0 @@
-import { buildHistoryContextFromEntries } from "../auto-reply/reply/history.js";
-export function buildAgentMessageFromConversationEntries(entries) {
-    if (entries.length === 0) {
-        return "";
-    }
-    // Prefer the last user/tool entry as "current message" so the agent responds to
-    // the latest user input or tool output, not the assistant's previous message.
-    let currentIndex = -1;
-    for (let i = entries.length - 1; i >= 0; i -= 1) {
-        const role = entries[i]?.role;
-        if (role === "user" || role === "tool") {
-            currentIndex = i;
-            break;
-        }
-    }
-    if (currentIndex < 0) {
-        currentIndex = entries.length - 1;
-    }
-    const currentEntry = entries[currentIndex]?.entry;
-    if (!currentEntry) {
-        return "";
-    }
-    const historyEntries = entries.slice(0, currentIndex).map((e) => e.entry);
-    if (historyEntries.length === 0) {
-        return currentEntry.body;
-    }
-    const formatEntry = (entry) => `${entry.sender}: ${entry.body}`;
-    return buildHistoryContextFromEntries({
-        entries: [...historyEntries, currentEntry],
-        currentMessage: formatEntry(currentEntry),
-        formatEntry,
-    });
-}

package/dist/gateway/assistant-identity.js

@@ -1,64 +0,0 @@
-import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agents/agent-scope.js";
-import { resolveAgentIdentity } from "../agents/identity.js";
-import { loadAgentIdentity } from "../commands/agents.config.js";
-import { normalizeAgentId } from "../routing/session-key.js";
-const MAX_ASSISTANT_NAME = 50;
-const MAX_ASSISTANT_AVATAR = 200;
-export const DEFAULT_ASSISTANT_IDENTITY = {
-    agentId: "main",
-    name: "Assistant",
-    avatar: "A",
-};
-function coerceIdentityValue(value, maxLength) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return undefined;
-    if (trimmed.length <= maxLength)
-        return trimmed;
-    return trimmed.slice(0, maxLength);
-}
-function isAvatarUrl(value) {
-    return /^https?:\/\//i.test(value) || /^data:image\//i.test(value);
-}
-function looksLikeAvatarPath(value) {
-    if (/[\\/]/.test(value))
-        return true;
-    return /\.(png|jpe?g|gif|webp|svg|ico)$/i.test(value);
-}
-function normalizeAvatarValue(value) {
-    if (!value)
-        return undefined;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return undefined;
-    if (isAvatarUrl(trimmed))
-        return trimmed;
-    if (looksLikeAvatarPath(trimmed))
-        return trimmed;
-    if (!/\s/.test(trimmed) && trimmed.length <= 4)
-        return trimmed;
-    return undefined;
-}
-export function resolveAssistantIdentity(params) {
-    const agentId = normalizeAgentId(params.agentId ?? resolveDefaultAgentId(params.cfg));
-    const workspaceDir = params.workspaceDir ?? resolveAgentWorkspaceDir(params.cfg, agentId);
-    const configAssistant = params.cfg.ui?.assistant;
-    const agentIdentity = resolveAgentIdentity(params.cfg, agentId);
-    const fileIdentity = workspaceDir ? loadAgentIdentity(workspaceDir) : null;
-    const name = coerceIdentityValue(configAssistant?.name, MAX_ASSISTANT_NAME) ??
-        coerceIdentityValue(agentIdentity?.name, MAX_ASSISTANT_NAME) ??
-        coerceIdentityValue(fileIdentity?.name, MAX_ASSISTANT_NAME) ??
-        DEFAULT_ASSISTANT_IDENTITY.name;
-    const avatarCandidates = [
-        coerceIdentityValue(configAssistant?.avatar, MAX_ASSISTANT_AVATAR),
-        coerceIdentityValue(agentIdentity?.avatar, MAX_ASSISTANT_AVATAR),
-        coerceIdentityValue(agentIdentity?.emoji, MAX_ASSISTANT_AVATAR),
-        coerceIdentityValue(fileIdentity?.avatar, MAX_ASSISTANT_AVATAR),
-        coerceIdentityValue(fileIdentity?.emoji, MAX_ASSISTANT_AVATAR),
-    ];
-    const avatar = avatarCandidates.map((candidate) => normalizeAvatarValue(candidate)).find(Boolean) ??
-        DEFAULT_ASSISTANT_IDENTITY.avatar;
-    return { agentId, name, avatar };
-}

package/dist/gateway/auth-rate-limit.js

@@ -1,155 +0,0 @@
-/**
- * In-memory sliding-window rate limiter for gateway authentication attempts.
- *
- * Tracks failed auth attempts by {scope, clientIp}. A scope lets callers keep
- * independent counters for different credential classes (for example, shared
- * gateway token/password vs device-token auth) while still sharing one
- * limiter instance.
- *
- * Design decisions:
- * - Pure in-memory Map – no external dependencies; suitable for a single
- *   gateway process.  The Map is periodically pruned to avoid unbounded
- *   growth.
- * - Loopback addresses (127.0.0.1 / ::1) are exempt by default so that local
- *   CLI sessions are never locked out.
- * - The module is side-effect-free: callers create an instance via
- *   {@link createAuthRateLimiter} and pass it where needed.
- */
-import { isLoopbackAddress } from "./net.js";
-export const AUTH_RATE_LIMIT_SCOPE_DEFAULT = "default";
-export const AUTH_RATE_LIMIT_SCOPE_SHARED_SECRET = "shared-secret";
-export const AUTH_RATE_LIMIT_SCOPE_DEVICE_TOKEN = "device-token";
-// ---------------------------------------------------------------------------
-// Defaults
-// ---------------------------------------------------------------------------
-const DEFAULT_MAX_ATTEMPTS = 10;
-const DEFAULT_WINDOW_MS = 60_000; // 1 minute
-const DEFAULT_LOCKOUT_MS = 300_000; // 5 minutes
-const PRUNE_INTERVAL_MS = 60_000; // prune stale entries every minute
-// Control-plane rate limiting: 3 requests per minute per device+IP
-// OpenClaw #32384 - prevents abuse of control-plane endpoints
-export const CONTROL_PLANE_MAX_ATTEMPTS = 3;
-export const CONTROL_PLANE_WINDOW_MS = 60_000; // 1 minute
-export const CONTROL_PLANE_LOCKOUT_MS = 300_000; // 5 minutes
-export const AUTH_RATE_LIMIT_SCOPE_CONTROL_PLANE = "control-plane";
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-export function createAuthRateLimiter(config) {
-    const maxAttempts = config?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-    const windowMs = config?.windowMs ?? DEFAULT_WINDOW_MS;
-    const lockoutMs = config?.lockoutMs ?? DEFAULT_LOCKOUT_MS;
-    const exemptLoopback = config?.exemptLoopback ?? true;
-    const entries = new Map();
-    // Periodic cleanup to avoid unbounded map growth.
-    const pruneTimer = setInterval(() => prune(), PRUNE_INTERVAL_MS);
-    // Allow the Node.js process to exit even if the timer is still active.
-    if (pruneTimer.unref) {
-        pruneTimer.unref();
-    }
-    function normalizeScope(scope) {
-        return (scope ?? AUTH_RATE_LIMIT_SCOPE_DEFAULT).trim() || AUTH_RATE_LIMIT_SCOPE_DEFAULT;
-    }
-    function normalizeIp(ip) {
-        return (ip ?? "").trim() || "unknown";
-    }
-    function resolveKey(rawIp, rawScope) {
-        const ip = normalizeIp(rawIp);
-        const scope = normalizeScope(rawScope);
-        return { key: `${scope}:${ip}`, ip };
-    }
-    function isExempt(ip) {
-        return exemptLoopback && isLoopbackAddress(ip);
-    }
-    function slideWindow(entry, now) {
-        const cutoff = now - windowMs;
-        // Remove attempts that fell outside the window.
-        entry.attempts = entry.attempts.filter((ts) => ts > cutoff);
-    }
-    function check(rawIp, rawScope) {
-        const { key, ip } = resolveKey(rawIp, rawScope);
-        if (isExempt(ip)) {
-            return { allowed: true, remaining: maxAttempts, retryAfterMs: 0 };
-        }
-        const now = Date.now();
-        const entry = entries.get(key);
-        if (!entry) {
-            return { allowed: true, remaining: maxAttempts, retryAfterMs: 0 };
-        }
-        // Still locked out?
-        if (entry.lockedUntil && now < entry.lockedUntil) {
-            return {
-                allowed: false,
-                remaining: 0,
-                retryAfterMs: entry.lockedUntil - now,
-            };
-        }
-        // Lockout expired – clear it.
-        if (entry.lockedUntil && now >= entry.lockedUntil) {
-            entry.lockedUntil = undefined;
-            entry.attempts = [];
-        }
-        slideWindow(entry, now);
-        const remaining = Math.max(0, maxAttempts - entry.attempts.length);
-        return { allowed: remaining > 0, remaining, retryAfterMs: 0 };
-    }
-    function recordFailure(rawIp, rawScope) {
-        const { key, ip } = resolveKey(rawIp, rawScope);
-        if (isExempt(ip)) {
-            return;
-        }
-        const now = Date.now();
-        let entry = entries.get(key);
-        if (!entry) {
-            entry = { attempts: [] };
-            entries.set(key, entry);
-        }
-        // If currently locked, do nothing (already blocked).
-        if (entry.lockedUntil && now < entry.lockedUntil) {
-            return;
-        }
-        slideWindow(entry, now);
-        entry.attempts.push(now);
-        if (entry.attempts.length >= maxAttempts) {
-            entry.lockedUntil = now + lockoutMs;
-        }
-    }
-    function reset(rawIp, rawScope) {
-        const { key } = resolveKey(rawIp, rawScope);
-        entries.delete(key);
-    }
-    function prune() {
-        const now = Date.now();
-        for (const [key, entry] of entries) {
-            // If locked out, keep the entry until the lockout expires.
-            if (entry.lockedUntil && now < entry.lockedUntil) {
-                continue;
-            }
-            slideWindow(entry, now);
-            if (entry.attempts.length === 0) {
-                entries.delete(key);
-            }
-        }
-    }
-    function size() {
-        return entries.size;
-    }
-    function dispose() {
-        clearInterval(pruneTimer);
-        entries.clear();
-    }
-    return { check, recordFailure, reset, size, prune, dispose };
-}
-/**
- * Create a rate limiter specifically for control-plane operations.
- * Uses stricter limits (3 req/min) to prevent abuse of sensitive endpoints.
- * OpenClaw #32384
- */
-export function createControlPlaneRateLimiter() {
-    return createAuthRateLimiter({
-        maxAttempts: CONTROL_PLANE_MAX_ATTEMPTS,
-        windowMs: CONTROL_PLANE_WINDOW_MS,
-        lockoutMs: CONTROL_PLANE_LOCKOUT_MS,
-        exemptLoopback: true, // Always exempt loopback for local development
-    });
-}