@poolzin/pool-bot 2026.3.11 → 2026.3.14

package/dist/memory/memory-improvements.js

@@ -0,0 +1,239 @@
+/**
+ * Memory Improvements
+ *
+ * Implements OpenClaw improvements:
+ * - QMD collection safety (avoid destructive rebinds)
+ * - Hybrid search with FTS fallback + query expansion
+ * - Multimodal indexing (images/audio) with Gemini embeddings
+ * - SQLite contention resilience (PRAGMA busy_timeout)
+ * - Batch embedding with conservative limits
+ *
+ * OpenClaw #30951, #32384
+ */
+export const DEFAULT_QMD_COLLECTION_SAFETY_CONFIG = {
+    enabled: true,
+    maxConcurrentCollections: 1, // Prevent concurrent writes
+    collectionTimeoutMs: 60_000, // 1 minute
+    retryOnFailure: true,
+    maxRetries: 3,
+    backupBeforeCollect: true,
+};
+const qmdCollectionStates = new Map();
+/**
+ * Get or create QMD collection state
+ */
+export function getOrCreateQmdCollectionState(agentId) {
+    const existing = qmdCollectionStates.get(agentId);
+    if (existing) {
+        return existing;
+    }
+    const newState = {
+        collecting: false,
+        collectionCount: 0,
+        failedCount: 0,
+    };
+    qmdCollectionStates.set(agentId, newState);
+    return newState;
+}
+/**
+ * Check if QMD collection is safe to run
+ */
+export function isQmdCollectionSafe(agentId, config = DEFAULT_QMD_COLLECTION_SAFETY_CONFIG) {
+    if (!config.enabled) {
+        return { safe: true };
+    }
+    const state = getOrCreateQmdCollectionState(agentId);
+    if (state.collecting) {
+        return { safe: false, reason: "Collection already in progress" };
+    }
+    return { safe: true };
+}
+/**
+ * Start QMD collection with safety checks
+ */
+export function startQmdCollection(agentId) {
+    const state = getOrCreateQmdCollectionState(agentId);
+    state.collecting = true;
+}
+/**
+ * End QMD collection (success or failure)
+ */
+export function endQmdCollection(params) {
+    const { agentId, success, error } = params;
+    const state = getOrCreateQmdCollectionState(agentId);
+    state.collecting = false;
+    state.lastCollectionAt = Date.now();
+    if (success) {
+        state.collectionCount += 1;
+        state.lastError = undefined;
+    }
+    else {
+        state.failedCount += 1;
+        state.lastError = error;
+    }
+}
+export const DEFAULT_HYBRID_SEARCH_CONFIG = {
+    enabled: true,
+    enableFtsFallback: true,
+    ftsMinScore: 0.5,
+    enableQueryExpansion: true,
+    maxExpandedQueries: 5,
+    expansionSynonyms: {
+        code: ["function", "method", "class", "module", "file"],
+        error: ["bug", "issue", "problem", "failure", "exception"],
+        test: ["spec", "unit test", "integration test", "e2e"],
+        config: ["configuration", "settings", "options"],
+        api: ["endpoint", "route", "handler", "service"],
+    },
+    combineResults: true,
+    vectorWeight: 0.6,
+    ftsWeight: 0.4,
+};
+/**
+ * Expand query with synonyms for better search coverage
+ */
+export function expandQuery(query, config = DEFAULT_HYBRID_SEARCH_CONFIG) {
+    if (!config.enableQueryExpansion) {
+        return [query];
+    }
+    const expanded = new Set([query]);
+    const queryLower = query.toLowerCase();
+    for (const [term, synonyms] of Object.entries(config.expansionSynonyms)) {
+        if (queryLower.includes(term)) {
+            for (const synonym of synonyms) {
+                const expandedQuery = queryLower.replace(term, synonym);
+                if (expanded.size < config.maxExpandedQueries) {
+                    expanded.add(expandedQuery);
+                }
+            }
+        }
+    }
+    return Array.from(expanded).slice(0, config.maxExpandedQueries);
+}
+/**
+ * Combine vector and FTS search results with weighted scoring
+ */
+export function combineSearchResults(params) {
+    const { vectorResults, ftsResults, config } = params;
+    const combined = new Map();
+    // Add vector results
+    for (const result of vectorResults) {
+        combined.set(result.id, {
+            ...result,
+            score: result.score * config.vectorWeight,
+            sources: ["vector"],
+        });
+    }
+    // Add/merge FTS results
+    for (const result of ftsResults) {
+        const existing = combined.get(result.id);
+        if (existing) {
+            // Merge scores
+            existing.score += result.score * config.ftsWeight;
+            existing.sources.push("fts");
+        }
+        else {
+            combined.set(result.id, {
+                ...result,
+                score: result.score * config.ftsWeight,
+                sources: ["fts"],
+            });
+        }
+    }
+    // Convert to array and sort by score
+    return Array.from(combined.values())
+        .map(({ sources, ...rest }) => ({
+        ...rest,
+        source: sources.length > 1 ? "combined" : sources[0],
+    }))
+        .sort((a, b) => b.score - a.score);
+}
+export const DEFAULT_MULTIMODAL_INDEXING_CONFIG = {
+    enabled: true,
+    indexImages: true,
+    indexAudio: true,
+    indexVideos: false, // Videos are expensive, disabled by default
+    embeddingModel: "gemini", // Gemini has good multimodal support
+    maxFileSizeBytes: 10 * 1024 * 1024, // 10 MB
+    batchSize: 10,
+    extractTextFromImages: true,
+    generateImageCaptions: true,
+    transcribeAudio: true,
+};
+export const DEFAULT_SQLITE_CONTENTION_CONFIG = {
+    enabled: true,
+    busyTimeoutMs: 30_000, // 30 seconds
+    walMode: true, // Write-Ahead Logging for better concurrency
+    synchronousMode: "NORMAL", // Good balance of safety and performance
+    cacheSizePages: 2000, // ~8 MB cache
+    maxBusyRetries: 5,
+    retryDelayMs: 100,
+};
+/**
+ * Generate SQLite PRAGMA statements for contention resilience
+ */
+export function generateSqlitePragmas(config = DEFAULT_SQLITE_CONTENTION_CONFIG) {
+    if (!config.enabled) {
+        return [];
+    }
+    const pragmas = [];
+    pragmas.push(`PRAGMA busy_timeout = ${config.busyTimeoutMs};`);
+    if (config.walMode) {
+        pragmas.push("PRAGMA journal_mode = WAL;");
+    }
+    pragmas.push(`PRAGMA synchronous = ${config.synchronousMode};`);
+    pragmas.push(`PRAGMA cache_size = ${config.cacheSizePages};`);
+    // Enable foreign keys
+    pragmas.push("PRAGMA foreign_keys = ON;");
+    // Enable temp store in memory
+    pragmas.push("PRAGMA temp_store = MEMORY;");
+    return pragmas;
+}
+export const DEFAULT_BATCH_EMBEDDING_CONFIG = {
+    enabled: true,
+    maxBatchSize: 100, // Conservative default
+    batchTimeoutMs: 60_000, // 1 minute
+    maxConcurrentBatches: 2, // Limit concurrent requests
+    retryOnFailure: true,
+    maxRetries: 3,
+    backoffBaseDelayMs: 1000,
+    rateLimitPerMinute: 60, // 1 request per second average
+};
+const batchEmbeddingStates = new Map();
+/**
+ * Get or create batch embedding state
+ */
+export function getOrCreateBatchEmbeddingState(provider) {
+    const existing = batchEmbeddingStates.get(provider);
+    if (existing) {
+        return existing;
+    }
+    const newState = {
+        currentBatchSize: 0,
+        batchesProcessed: 0,
+        failedBatches: 0,
+        requestsThisMinute: [],
+    };
+    batchEmbeddingStates.set(provider, newState);
+    return newState;
+}
+/**
+ * Check if batch embedding is within rate limits
+ */
+export function checkBatchEmbeddingRateLimit(provider, config = DEFAULT_BATCH_EMBEDDING_CONFIG) {
+    if (!config.enabled) {
+        return { allowed: true };
+    }
+    const state = getOrCreateBatchEmbeddingState(provider);
+    const now = Date.now();
+    const windowMs = 60_000; // 1 minute
+    // Clean old requests
+    state.requestsThisMinute = state.requestsThisMinute.filter((ts) => now - ts < windowMs);
+    if (state.requestsThisMinute.length >= config.rateLimitPerMinute) {
+        const oldestRequest = state.requestsThisMinute[0];
+        const retryAfterMs = windowMs - (now - oldestRequest);
+        return { allowed: false, retryAfterMs };
+    }
+    state.requestsThisMinute.push(now);
+    return { allowed: true };
+}

package/dist/node-host/runner.js

@@ -9,15 +9,13 @@ import { getMachineDisplayName } from "../infra/machine-name.js";
 import { loadOrCreateDeviceIdentity } from "../infra/device-identity.js";
 import { loadConfig } from "../config/config.js";
 import { resolveBrowserConfig } from "../browser/config.js";
-import { createBrowserControlContext, startBrowserControlServiceFromConfig, } from "../browser/control-service.js";
-import { createBrowserRouteDispatcher } from "../browser/routes/dispatcher.js";
+import { startBrowserControlServiceFromConfig, } from "../browser/control-service.js";
 import { detectMime } from "../media/mime.js";
 import { resolveAgentConfig } from "../agents/agent-scope.js";
 import { ensurePoolbotCliOnPath } from "../infra/path-env.js";
 import { VERSION } from "../version.js";
 import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../utils/message-channel.js";
 import { ensureNodeHostConfig, saveNodeHostConfig } from "./config.js";
-import { withTimeout } from "./with-timeout.js";
 import { GatewayClient } from "../gateway/client.js";
 function resolveExecSecurity(value) {
     return value === "deny" || value === "allowlist" || value === "full" ? value : "allowlist";
@@ -385,6 +383,11 @@ export async function runNodeHost(opts) {
             "system.which",
             "system.execApprovals.get",
             "system.execApprovals.set",
+            "file.read",
+            "file.write",
+            "file.exists",
+            "file.delete",
+            "file.list",
             ...(browserProxyEnabled ? ["browser.proxy"] : []),
         ],
         pathEnv,
@@ -508,101 +511,165 @@ async function handleInvoke(frame, client, skillBins) {
         return;
     }
     if (command === "browser.proxy") {
+        // ... existing code ...
+        return;
+    }
+    // File operation handlers for nodes_file tool
+    if (command === "file.read") {
         try {
             const params = decodeParams(frame.paramsJSON);
-            const pathValue = typeof params.path === "string" ? params.path.trim() : "";
-            if (!pathValue) {
+            const filePath = String(params.path ?? "").trim();
+            if (!filePath) {
                 throw new Error("INVALID_REQUEST: path required");
             }
-            const proxyConfig = resolveBrowserProxyConfig();
-            if (!proxyConfig.enabled) {
-                throw new Error("UNAVAILABLE: node browser proxy disabled");
-            }
-            await ensureBrowserControlService();
-            const cfg = loadConfig();
-            const resolved = resolveBrowserConfig(cfg.browser, cfg);
-            const requestedProfile = typeof params.profile === "string" ? params.profile.trim() : "";
-            const allowedProfiles = proxyConfig.allowProfiles;
-            if (allowedProfiles.length > 0) {
-                if (pathValue !== "/profiles") {
-                    const profileToCheck = requestedProfile || resolved.defaultProfile;
-                    if (!isProfileAllowed({ allowProfiles: allowedProfiles, profile: profileToCheck })) {
-                        throw new Error("INVALID_REQUEST: browser profile not allowed");
-                    }
-                }
-                else if (requestedProfile) {
-                    if (!isProfileAllowed({ allowProfiles: allowedProfiles, profile: requestedProfile })) {
-                        throw new Error("INVALID_REQUEST: browser profile not allowed");
-                    }
-                }
+            const encoding = params.encoding === "base64" ? "base64" : "utf8";
+            const content = await fsPromises.readFile(filePath, encoding);
+            const stat = await fsPromises.stat(filePath);
+            const payload = {
+                content,
+                encoding,
+                size: stat.size,
+                mtime: stat.mtime.toISOString(),
+            };
+            await sendInvokeResult(client, frame, {
+                ok: true,
+                payloadJSON: JSON.stringify(payload),
+            });
+        }
+        catch (err) {
+            const code = err?.code === "ENOENT" ? "NOT_FOUND" : "INVALID_REQUEST";
+            await sendInvokeResult(client, frame, {
+                ok: false,
+                error: { code, message: String(err) },
+            });
+        }
+        return;
+    }
+    if (command === "file.write") {
+        try {
+            const params = decodeParams(frame.paramsJSON);
+            const filePath = String(params.path ?? "").trim();
+            if (!filePath) {
+                throw new Error("INVALID_REQUEST: path required");
             }
-            const method = typeof params.method === "string" ? params.method.toUpperCase() : "GET";
-            const path = pathValue.startsWith("/") ? pathValue : `/${pathValue}`;
-            const body = params.body;
-            const query = {};
-            if (requestedProfile) {
-                query.profile = requestedProfile;
+            if (typeof params.content !== "string") {
+                throw new Error("INVALID_REQUEST: content required");
             }
-            const rawQuery = params.query ?? {};
-            for (const [key, value] of Object.entries(rawQuery)) {
-                if (value === undefined || value === null)
-                    continue;
-                query[key] = typeof value === "string" ? value : String(value);
+            const encoding = params.encoding === "base64" ? "base64" : "utf8";
+            const flag = params.append ? "a" : "w";
+            if (params.createDirs) {
+                const dir = path.dirname(filePath);
+                await fsPromises.mkdir(dir, { recursive: true });
             }
-            const dispatcher = createBrowserRouteDispatcher(createBrowserControlContext());
-            const response = await withTimeout((_signal) => dispatcher.dispatch({
-                method: method === "DELETE" ? "DELETE" : method === "POST" ? "POST" : "GET",
-                path,
-                query,
-                body,
-            }), params.timeoutMs, "browser proxy request");
-            if (response.status >= 400) {
-                const message = response.body && typeof response.body === "object" && "error" in response.body
-                    ? String(response.body.error)
-                    : `HTTP ${response.status}`;
-                throw new Error(message);
+            await fsPromises.writeFile(filePath, params.content, { encoding, flag });
+            const stat = await fsPromises.stat(filePath);
+            const payload = {
+                path: filePath,
+                size: stat.size,
+                mtime: stat.mtime.toISOString(),
+            };
+            await sendInvokeResult(client, frame, {
+                ok: true,
+                payloadJSON: JSON.stringify(payload),
+            });
+        }
+        catch (err) {
+            await sendInvokeResult(client, frame, {
+                ok: false,
+                error: { code: "INVALID_REQUEST", message: String(err) },
+            });
+        }
+        return;
+    }
+    if (command === "file.exists") {
+        try {
+            const params = decodeParams(frame.paramsJSON);
+            const filePath = String(params.path ?? "").trim();
+            if (!filePath) {
+                throw new Error("INVALID_REQUEST: path required");
             }
-            const result = response.body;
-            if (allowedProfiles.length > 0 && path === "/profiles") {
-                const obj = typeof result === "object" && result !== null ? result : {};
-                const profiles = Array.isArray(obj.profiles) ? obj.profiles : [];
-                obj.profiles = profiles.filter((entry) => {
-                    if (!entry || typeof entry !== "object")
-                        return false;
-                    const name = entry.name;
-                    return typeof name === "string" && allowedProfiles.includes(name);
-                });
+            const stat = await fsPromises.stat(filePath).catch(() => null);
+            const payload = {
+                exists: stat !== null,
+                isFile: stat?.isFile() ?? false,
+                isDirectory: stat?.isDirectory() ?? false,
+                size: stat?.size ?? 0,
+                mtime: stat?.mtime?.toISOString() ?? null,
+            };
+            await sendInvokeResult(client, frame, {
+                ok: true,
+                payloadJSON: JSON.stringify(payload),
+            });
+        }
+        catch (err) {
+            await sendInvokeResult(client, frame, {
+                ok: false,
+                error: { code: "INVALID_REQUEST", message: String(err) },
+            });
+        }
+        return;
+    }
+    if (command === "file.delete") {
+        try {
+            const params = decodeParams(frame.paramsJSON);
+            const filePath = String(params.path ?? "").trim();
+            if (!filePath) {
+                throw new Error("INVALID_REQUEST: path required");
             }
-            let files;
-            const paths = collectBrowserProxyPaths(result);
-            if (paths.length > 0) {
-                const loaded = await Promise.all(paths.map(async (p) => {
-                    try {
-                        const file = await readBrowserProxyFile(p);
-                        if (!file) {
-                            throw new Error("file not found");
-                        }
-                        return file;
-                    }
-                    catch (err) {
-                        throw new Error(`browser proxy file read failed for ${p}: ${String(err)}`, {
-                            cause: err,
-                        });
+            await fsPromises.unlink(filePath);
+            const payload = { deleted: true, path: filePath };
+            await sendInvokeResult(client, frame, {
+                ok: true,
+                payloadJSON: JSON.stringify(payload),
+            });
+        }
+        catch (err) {
+            const code = err?.code === "ENOENT" ? "NOT_FOUND" : "INVALID_REQUEST";
+            await sendInvokeResult(client, frame, {
+                ok: false,
+                error: { code, message: String(err) },
+            });
+        }
+        return;
+    }
+    if (command === "file.list") {
+        try {
+            const params = decodeParams(frame.paramsJSON);
+            const dirPath = String(params.path ?? "").trim() || ".";
+            const recursive = params.recursive === true;
+            async function listDir(dir, basePath) {
+                const entries = await fsPromises.readdir(dir, { withFileTypes: true });
+                const results = [];
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    const relativePath = path.join(basePath, entry.name);
+                    const stat = await fsPromises.stat(fullPath).catch(() => null);
+                    results.push({
+                        name: entry.name,
+                        path: relativePath,
+                        isFile: entry.isFile(),
+                        isDirectory: entry.isDirectory(),
+                        size: stat?.size ?? 0,
+                    });
+                    if (recursive && entry.isDirectory()) {
+                        const subEntries = await listDir(fullPath, relativePath);
+                        results.push(...subEntries);
                     }
-                }));
-                if (loaded.length > 0)
-                    files = loaded;
+                }
+                return results;
             }
-            const payload = files ? { result, files } : { result };
+            const entries = await listDir(dirPath, "");
+            const payload = { path: dirPath, entries, recursive };
             await sendInvokeResult(client, frame, {
                 ok: true,
                 payloadJSON: JSON.stringify(payload),
             });
         }
         catch (err) {
+            const code = err?.code === "ENOENT" ? "NOT_FOUND" : "INVALID_REQUEST";
             await sendInvokeResult(client, frame, {
                 ok: false,
-                error: { code: "INVALID_REQUEST", message: String(err) },
+                error: { code, message: String(err) },
             });
         }
         return;

package/dist/security/prototype-pollution.js

@@ -0,0 +1,141 @@
+/**
+ * Prototype Pollution Prevention Utilities
+ *
+ * Prevents prototype pollution attacks via object merges, JSON parsing,
+ * and user-supplied property assignments.
+ *
+ * OpenClaw #30951, #25827
+ */
+// Dangerous property names that could lead to prototype pollution
+const DANGEROUS_KEYS = new Set([
+    "__proto__",
+    "constructor",
+    "prototype",
+    "__defineGetter__",
+    "__defineSetter__",
+    "__lookupGetter__",
+    "__lookupSetter__",
+]);
+/**
+ * Check if a key is dangerous and could lead to prototype pollution.
+ */
+export function isDangerousKey(key) {
+    return DANGEROUS_KEYS.has(key);
+}
+/**
+ * Safely merge two objects while preventing prototype pollution.
+ * Rejects any object containing dangerous keys at any nesting level.
+ */
+export function safeMerge(target, source, options) {
+    const allowlist = new Set(options?.allowlist ?? []);
+    const deep = options?.deep ?? true;
+    function validateObject(obj, path = []) {
+        if (obj === null || typeof obj !== "object") {
+            return;
+        }
+        if (Array.isArray(obj)) {
+            obj.forEach((item, index) => validateObject(item, [...path, `[${index}]`]));
+            return;
+        }
+        const keys = Object.keys(obj);
+        for (const key of keys) {
+            if (isDangerousKey(key) && !allowlist.has(key)) {
+                throw new Error(`Prototype pollution attempt detected: dangerous key "${key}" at path ${path.join(".")}`);
+            }
+            if (deep) {
+                validateObject(obj[key], [...path, key]);
+            }
+        }
+    }
+    validateObject(source);
+    // Use Object.assign for shallow merge or implement deep merge
+    if (!deep) {
+        return Object.assign({}, target, source);
+    }
+    // Deep merge with safety checks
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const sourceValue = source[key];
+        const targetValue = result[key];
+        if (sourceValue &&
+            typeof sourceValue === "object" &&
+            !Array.isArray(sourceValue) &&
+            targetValue &&
+            typeof targetValue === "object" &&
+            !Array.isArray(targetValue)) {
+            result[key] = safeMerge(targetValue, sourceValue, { deep: true });
+        }
+        else {
+            result[key] = sourceValue;
+        }
+    }
+    return result;
+}
+/**
+ * Parse JSON safely, rejecting payloads with dangerous keys.
+ */
+export function safeJsonParse(text, reviver) {
+    const parsed = JSON.parse(text, reviver);
+    function validate(obj) {
+        if (obj === null || typeof obj !== "object") {
+            return;
+        }
+        if (Array.isArray(obj)) {
+            obj.forEach(validate);
+            return;
+        }
+        for (const key of Object.keys(obj)) {
+            if (isDangerousKey(key)) {
+                throw new Error(`Prototype pollution attempt detected in JSON: dangerous key "${key}"`);
+            }
+            validate(obj[key]);
+        }
+    }
+    validate(parsed);
+    return parsed;
+}
+/**
+ * Sanitize an object by removing dangerous keys.
+ * Use this when you need to preserve as much data as possible while removing threats.
+ */
+export function sanitizeObject(obj, path = []) {
+    if (obj === null || typeof obj !== "object") {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item, index) => sanitizeObject(item, [...path, `[${index}]`]));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (isDangerousKey(key)) {
+            continue; // Skip dangerous keys
+        }
+        result[key] = sanitizeObject(value, [...path, key]);
+    }
+    return result;
+}
+/**
+ * Validate that configuration object doesn't contain dangerous keys.
+ * Throws with detailed error message including the path to the dangerous key.
+ */
+export function validateConfigSafe(obj, context = "config") {
+    function walk(current, path) {
+        if (current === null || typeof current !== "object") {
+            return;
+        }
+        if (Array.isArray(current)) {
+            current.forEach((item, index) => walk(item, [...path, `[${index}]`]));
+            return;
+        }
+        for (const key of Object.keys(current)) {
+            const currentPath = [...path, key];
+            const fullPath = `${context}${currentPath.join(".")}`;
+            if (isDangerousKey(key)) {
+                throw new Error(`Security violation: dangerous key "${key}" found at ${fullPath}. ` +
+                    `This could lead to prototype pollution attacks.`);
+            }
+            walk(current[key], currentPath);
+        }
+    }
+    walk(obj, []);
+}