@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+## v2026.2.22 (2026-02-18)
+
+### Features
+- **Upstream Sync (openclaw 639d0221):** major sync with upstream — 402 files updated covering agents, auto-reply, gateway, channels, infra, and cron
+  - **Agent tooling:** API key rotation, image sanitization, tool-result context guard, sandbox env var sanitization
+  - **Auto-reply:** reply dispatcher reservation pattern, abort memory tracking with cascade support, subagent info 30-minute recency window, `compact` as native command
+  - **Gateway:** presence events, protocol schema updates, mesh removal
+  - **Channels:** Telegram replyToMode defaults to off, Discord REST fetch helper, Slack streaming support
+  - **Infra:** exec-safe binary trust, install-source utilities, string normalization
+  - **Cron:** stagger scheduling for distributed job execution
+  - **Markdown:** nested list rendering now uses proper newline+indentation (blockquote style support)
+
+### Fixes
+- **Slack format:** updated nested list test expectation to match upstream markdown IR changes
+
+---
+
 ## v2026.2.21 (2026-02-18)
 
 ### Features

package/dist/agents/api-key-rotation.js

@@ -0,0 +1,47 @@
+import { formatErrorMessage } from "../infra/errors.js";
+import { collectProviderApiKeys, isApiKeyRateLimitError } from "./live-auth-keys.js";
+function dedupeApiKeys(raw) {
+    const seen = new Set();
+    const keys = [];
+    for (const value of raw) {
+        const apiKey = value.trim();
+        if (!apiKey || seen.has(apiKey)) {
+            continue;
+        }
+        seen.add(apiKey);
+        keys.push(apiKey);
+    }
+    return keys;
+}
+export function collectProviderApiKeysForExecution(params) {
+    const { primaryApiKey, provider } = params;
+    return dedupeApiKeys([primaryApiKey?.trim() ?? "", ...collectProviderApiKeys(provider)]);
+}
+export async function executeWithApiKeyRotation(params) {
+    const keys = dedupeApiKeys(params.apiKeys);
+    if (keys.length === 0) {
+        throw new Error(`No API keys configured for provider "${params.provider}".`);
+    }
+    let lastError;
+    for (let attempt = 0; attempt < keys.length; attempt += 1) {
+        const apiKey = keys[attempt];
+        try {
+            return await params.execute(apiKey);
+        }
+        catch (error) {
+            lastError = error;
+            const message = formatErrorMessage(error);
+            const retryable = params.shouldRetry
+                ? params.shouldRetry({ apiKey, error, attempt, message })
+                : isApiKeyRateLimitError(message);
+            if (!retryable || attempt + 1 >= keys.length) {
+                break;
+            }
+            params.onRetry?.({ apiKey, error, attempt, message });
+        }
+    }
+    if (lastError === undefined) {
+        throw new Error(`Failed to run API request for ${params.provider}.`);
+    }
+    throw lastError;
+}

package/dist/agents/apply-patch-update.js

@@ -1,6 +1,10 @@
 import fs from "node:fs/promises";
-export async function applyUpdateHunk(filePath, chunks) {
-    const originalContents = await fs.readFile(filePath, "utf8").catch((err) => {
+async function defaultReadFile(filePath) {
+    return fs.readFile(filePath, "utf8");
+}
+export async function applyUpdateHunk(filePath, chunks, options) {
+    const reader = options?.readFile ?? defaultReadFile;
+    const originalContents = await reader(filePath).catch((err) => {
         throw new Error(`Failed to read file to update ${filePath}: ${err}`);
     });
     const originalLines = originalContents.split("\n");
@@ -53,7 +57,7 @@ function computeReplacements(originalLines, filePath, chunks) {
 }
 function applyReplacements(lines, replacements) {
     const result = [...lines];
-    for (const [startIndex, oldLen, newLines] of [...replacements].reverse()) {
+    for (const [startIndex, oldLen, newLines] of [...replacements].toReversed()) {
         for (let i = 0; i < oldLen; i += 1) {
             if (startIndex < result.length) {
                 result.splice(startIndex, 1);
@@ -66,25 +70,31 @@ function applyReplacements(lines, replacements) {
     return result;
 }
 function seekSequence(lines, pattern, start, eof) {
-    if (pattern.length === 0)
+    if (pattern.length === 0) {
         return start;
-    if (pattern.length > lines.length)
+    }
+    if (pattern.length > lines.length) {
         return null;
+    }
     const maxStart = lines.length - pattern.length;
     const searchStart = eof && lines.length >= pattern.length ? maxStart : start;
-    if (searchStart > maxStart)
+    if (searchStart > maxStart) {
         return null;
+    }
     for (let i = searchStart; i <= maxStart; i += 1) {
-        if (linesMatch(lines, pattern, i, (value) => value))
+        if (linesMatch(lines, pattern, i, (value) => value)) {
             return i;
+        }
     }
     for (let i = searchStart; i <= maxStart; i += 1) {
-        if (linesMatch(lines, pattern, i, (value) => value.trimEnd()))
+        if (linesMatch(lines, pattern, i, (value) => value.trimEnd())) {
             return i;
+        }
     }
     for (let i = searchStart; i <= maxStart; i += 1) {
-        if (linesMatch(lines, pattern, i, (value) => value.trim()))
+        if (linesMatch(lines, pattern, i, (value) => value.trim())) {
             return i;
+        }
     }
     for (let i = searchStart; i <= maxStart; i += 1) {
         if (linesMatch(lines, pattern, i, (value) => normalizePunctuation(value.trim()))) {

package/dist/agents/apply-patch.js

@@ -1,9 +1,8 @@
 import fs from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 import { Type } from "@sinclair/typebox";
 import { applyUpdateHunk } from "./apply-patch-update.js";
-import { assertSandboxPath } from "./sandbox-paths.js";
+import { assertSandboxPath, resolveSandboxInputPath } from "./sandbox-paths.js";
 const BEGIN_PATCH_MARKER = "*** Begin Patch";
 const END_PATCH_MARKER = "*** End Patch";
 const ADD_FILE_MARKER = "*** Add File: ";
@@ -13,7 +12,6 @@ const MOVE_TO_MARKER = "*** Move to: ";
 const EOF_MARKER = "*** End of File";
 const CHANGE_CONTEXT_MARKER = "@@ ";
 const EMPTY_CHANGE_CONTEXT_MARKER = "@@";
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
 const applyPatchSchema = Type.Object({
     input: Type.String({
         description: "Patch content using the *** Begin Patch/End Patch format.",
@@ -21,7 +19,8 @@ const applyPatchSchema = Type.Object({
 });
 export function createApplyPatchTool(options = {}) {
     const cwd = options.cwd ?? process.cwd();
-    const sandboxRoot = options.sandboxRoot;
+    const sandbox = options.sandbox;
+    const workspaceOnly = options.workspaceOnly !== false;
     return {
         name: "apply_patch",
         label: "apply_patch",
@@ -40,7 +39,8 @@ export function createApplyPatchTool(options = {}) {
             }
             const result = await applyPatch(input, {
                 cwd,
-                sandboxRoot,
+                sandbox,
+                workspaceOnly,
                 signal,
             });
             return {
@@ -65,6 +65,7 @@ export async function applyPatch(input, options) {
         modified: new Set(),
         deleted: new Set(),
     };
+    const fileOps = resolvePatchFileOps(options);
     for (const hunk of parsed.hunks) {
         if (options.signal?.aborted) {
             const err = new Error("Aborted");
@@ -73,28 +74,30 @@ export async function applyPatch(input, options) {
         }
         if (hunk.kind === "add") {
             const target = await resolvePatchPath(hunk.path, options);
-            await ensureDir(target.resolved);
-            await fs.writeFile(target.resolved, hunk.contents, "utf8");
+            await ensureDir(target.resolved, fileOps);
+            await fileOps.writeFile(target.resolved, hunk.contents);
             recordSummary(summary, seen, "added", target.display);
             continue;
         }
         if (hunk.kind === "delete") {
-            const target = await resolvePatchPath(hunk.path, options);
-            await fs.rm(target.resolved);
+            const target = await resolvePatchPath(hunk.path, options, "unlink");
+            await fileOps.remove(target.resolved);
             recordSummary(summary, seen, "deleted", target.display);
             continue;
         }
         const target = await resolvePatchPath(hunk.path, options);
-        const applied = await applyUpdateHunk(target.resolved, hunk.chunks);
+        const applied = await applyUpdateHunk(target.resolved, hunk.chunks, {
+            readFile: (path) => fileOps.readFile(path),
+        });
         if (hunk.movePath) {
             const moveTarget = await resolvePatchPath(hunk.movePath, options);
-            await ensureDir(moveTarget.resolved);
-            await fs.writeFile(moveTarget.resolved, applied, "utf8");
-            await fs.rm(target.resolved);
+            await ensureDir(moveTarget.resolved, fileOps);
+            await fileOps.writeFile(moveTarget.resolved, applied);
+            await fileOps.remove(target.resolved);
             recordSummary(summary, seen, "modified", moveTarget.display);
         }
         else {
-            await fs.writeFile(target.resolved, applied, "utf8");
+            await fileOps.writeFile(target.resolved, applied);
             recordSummary(summary, seen, "modified", target.display);
         }
     }
@@ -104,68 +107,88 @@ export async function applyPatch(input, options) {
     };
 }
 function recordSummary(summary, seen, bucket, value) {
-    if (seen[bucket].has(value))
+    if (seen[bucket].has(value)) {
         return;
+    }
     seen[bucket].add(value);
     summary[bucket].push(value);
 }
 function formatSummary(summary) {
     const lines = ["Success. Updated the following files:"];
-    for (const file of summary.added)
+    for (const file of summary.added) {
         lines.push(`A ${file}`);
-    for (const file of summary.modified)
+    }
+    for (const file of summary.modified) {
         lines.push(`M ${file}`);
-    for (const file of summary.deleted)
+    }
+    for (const file of summary.deleted) {
         lines.push(`D ${file}`);
+    }
     return lines.join("\n");
 }
-async function ensureDir(filePath) {
+function resolvePatchFileOps(options) {
+    if (options.sandbox) {
+        const { root, bridge } = options.sandbox;
+        return {
+            readFile: async (filePath) => {
+                const buf = await bridge.readFile({ filePath, cwd: root });
+                return buf.toString("utf8");
+            },
+            writeFile: (filePath, content) => bridge.writeFile({ filePath, cwd: root, data: content }),
+            remove: (filePath) => bridge.remove({ filePath, cwd: root, force: false }),
+            mkdirp: (dir) => bridge.mkdirp({ filePath: dir, cwd: root }),
+        };
+    }
+    return {
+        readFile: (filePath) => fs.readFile(filePath, "utf8"),
+        writeFile: (filePath, content) => fs.writeFile(filePath, content, "utf8"),
+        remove: (filePath) => fs.rm(filePath),
+        mkdirp: (dir) => fs.mkdir(dir, { recursive: true }).then(() => { }),
+    };
+}
+async function ensureDir(filePath, ops) {
     const parent = path.dirname(filePath);
-    if (!parent || parent === ".")
+    if (!parent || parent === ".") {
         return;
-    await fs.mkdir(parent, { recursive: true });
+    }
+    await ops.mkdirp(parent);
 }
-async function resolvePatchPath(filePath, options) {
-    if (options.sandboxRoot) {
-        const resolved = await assertSandboxPath({
+async function resolvePatchPath(filePath, options, purpose = "readWrite") {
+    if (options.sandbox) {
+        const resolved = options.sandbox.bridge.resolvePath({
             filePath,
             cwd: options.cwd,
-            root: options.sandboxRoot,
         });
         return {
-            resolved: resolved.resolved,
-            display: resolved.relative || resolved.resolved,
+            resolved: resolved.hostPath,
+            display: resolved.relativePath || resolved.hostPath,
         };
     }
-    const resolved = resolvePathFromCwd(filePath, options.cwd);
+    const workspaceOnly = options.workspaceOnly !== false;
+    const resolved = workspaceOnly
+        ? (await assertSandboxPath({
+            filePath,
+            cwd: options.cwd,
+            root: options.cwd,
+            allowFinalSymlink: purpose === "unlink",
+        })).resolved
+        : resolvePathFromCwd(filePath, options.cwd);
     return {
         resolved,
         display: toDisplayPath(resolved, options.cwd),
     };
 }
-function normalizeUnicodeSpaces(value) {
-    return value.replace(UNICODE_SPACES, " ");
-}
-function expandPath(filePath) {
-    const normalized = normalizeUnicodeSpaces(filePath);
-    if (normalized === "~")
-        return os.homedir();
-    if (normalized.startsWith("~/"))
-        return os.homedir() + normalized.slice(1);
-    return normalized;
-}
 function resolvePathFromCwd(filePath, cwd) {
-    const expanded = expandPath(filePath);
-    if (path.isAbsolute(expanded))
-        return path.normalize(expanded);
-    return path.resolve(cwd, expanded);
+    return path.normalize(resolveSandboxInputPath(filePath, cwd));
 }
 function toDisplayPath(resolved, cwd) {
     const relative = path.relative(cwd, resolved);
-    if (!relative || relative === "")
+    if (!relative || relative === "") {
         return path.basename(resolved);
-    if (relative.startsWith("..") || path.isAbsolute(relative))
+    }
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
         return resolved;
+    }
     return relative;
 }
 function parsePatchText(input) {
@@ -189,8 +212,9 @@ function parsePatchText(input) {
 }
 function checkPatchBoundariesLenient(lines) {
     const strictError = checkPatchBoundariesStrict(lines);
-    if (!strictError)
+    if (!strictError) {
         return lines;
+    }
     if (lines.length < 4) {
         throw new Error(strictError);
     }
@@ -199,8 +223,9 @@ function checkPatchBoundariesLenient(lines) {
     if ((first === "<<EOF" || first === "<<'EOF'" || first === '<<"EOF"') && last.endsWith("EOF")) {
         const inner = lines.slice(1, lines.length - 1);
         const innerError = checkPatchBoundariesStrict(inner);
-        if (!innerError)
+        if (!innerError) {
             return inner;
+        }
         throw new Error(innerError);
     }
     throw new Error(strictError);