@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/dist/memory/temporal-decay.js

@@ -0,0 +1,119 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export const DEFAULT_TEMPORAL_DECAY_CONFIG = {
+    enabled: false,
+    halfLifeDays: 30,
+};
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DATED_MEMORY_PATH_RE = /(?:^|\/)memory\/(\d{4})-(\d{2})-(\d{2})\.md$/;
+export function toDecayLambda(halfLifeDays) {
+    if (!Number.isFinite(halfLifeDays) || halfLifeDays <= 0) {
+        return 0;
+    }
+    return Math.LN2 / halfLifeDays;
+}
+export function calculateTemporalDecayMultiplier(params) {
+    const lambda = toDecayLambda(params.halfLifeDays);
+    const clampedAge = Math.max(0, params.ageInDays);
+    if (lambda <= 0 || !Number.isFinite(clampedAge)) {
+        return 1;
+    }
+    return Math.exp(-lambda * clampedAge);
+}
+export function applyTemporalDecayToScore(params) {
+    return params.score * calculateTemporalDecayMultiplier(params);
+}
+function parseMemoryDateFromPath(filePath) {
+    const normalized = filePath.replaceAll("\\", "/").replace(/^\.\//, "");
+    const match = DATED_MEMORY_PATH_RE.exec(normalized);
+    if (!match) {
+        return null;
+    }
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) {
+        return null;
+    }
+    const timestamp = Date.UTC(year, month - 1, day);
+    const parsed = new Date(timestamp);
+    if (parsed.getUTCFullYear() !== year ||
+        parsed.getUTCMonth() !== month - 1 ||
+        parsed.getUTCDate() !== day) {
+        return null;
+    }
+    return parsed;
+}
+function isEvergreenMemoryPath(filePath) {
+    const normalized = filePath.replaceAll("\\", "/").replace(/^\.\//, "");
+    if (normalized === "MEMORY.md" || normalized === "memory.md") {
+        return true;
+    }
+    if (!normalized.startsWith("memory/")) {
+        return false;
+    }
+    return !DATED_MEMORY_PATH_RE.test(normalized);
+}
+async function extractTimestamp(params) {
+    const fromPath = parseMemoryDateFromPath(params.filePath);
+    if (fromPath) {
+        return fromPath;
+    }
+    // Memory root/topic files are evergreen knowledge and should not decay.
+    if (params.source === "memory" && isEvergreenMemoryPath(params.filePath)) {
+        return null;
+    }
+    if (!params.workspaceDir) {
+        return null;
+    }
+    const absolutePath = path.isAbsolute(params.filePath)
+        ? params.filePath
+        : path.resolve(params.workspaceDir, params.filePath);
+    try {
+        const stat = await fs.stat(absolutePath);
+        if (!Number.isFinite(stat.mtimeMs)) {
+            return null;
+        }
+        return new Date(stat.mtimeMs);
+    }
+    catch {
+        return null;
+    }
+}
+function ageInDaysFromTimestamp(timestamp, nowMs) {
+    const ageMs = Math.max(0, nowMs - timestamp.getTime());
+    return ageMs / DAY_MS;
+}
+export async function applyTemporalDecayToHybridResults(params) {
+    const config = { ...DEFAULT_TEMPORAL_DECAY_CONFIG, ...params.temporalDecay };
+    if (!config.enabled) {
+        return [...params.results];
+    }
+    const nowMs = params.nowMs ?? Date.now();
+    const timestampPromiseCache = new Map();
+    return Promise.all(params.results.map(async (entry) => {
+        const cacheKey = `${entry.source}:${entry.path}`;
+        let timestampPromise = timestampPromiseCache.get(cacheKey);
+        if (!timestampPromise) {
+            timestampPromise = extractTimestamp({
+                filePath: entry.path,
+                source: entry.source,
+                workspaceDir: params.workspaceDir,
+            });
+            timestampPromiseCache.set(cacheKey, timestampPromise);
+        }
+        const timestamp = await timestampPromise;
+        if (!timestamp) {
+            return entry;
+        }
+        const decayedScore = applyTemporalDecayToScore({
+            score: entry.score,
+            ageInDays: ageInDaysFromTimestamp(timestamp, nowMs),
+            halfLifeDays: config.halfLifeDays,
+        });
+        return {
+            ...entry,
+            score: decayedScore,
+        };
+    }));
+}

package/dist/memory/test-embeddings-mock.js

@@ -0,0 +1,16 @@
+export function createOpenAIEmbeddingProviderMock(params) {
+    return {
+        requestedProvider: "openai",
+        provider: {
+            id: "openai",
+            model: "text-embedding-3-small",
+            embedQuery: params.embedQuery,
+            embedBatch: params.embedBatch,
+        },
+        openAi: {
+            baseUrl: "https://api.openai.com/v1",
+            headers: { Authorization: "Bearer test", "Content-Type": "application/json" },
+            model: "text-embedding-3-small",
+        },
+    };
+}

package/dist/memory/test-manager-helpers.js

@@ -0,0 +1,14 @@
+import { getMemorySearchManager } from "./index.js";
+export async function getRequiredMemoryIndexManager(params) {
+    const result = await getMemorySearchManager({
+        cfg: params.cfg,
+        agentId: params.agentId ?? "main",
+    });
+    if (!result.manager) {
+        throw new Error("manager missing");
+    }
+    if (!("sync" in result.manager) || typeof result.manager.sync !== "function") {
+        throw new Error("manager does not support sync");
+    }
+    return result.manager;
+}

package/dist/memory/test-runtime-mocks.js

@@ -0,0 +1,11 @@
+import { vi } from "vitest";
+// Unit tests: avoid importing the real chokidar implementation (native fsevents, etc.).
+vi.mock("chokidar", () => ({
+    default: {
+        watch: () => ({ on: () => { }, close: async () => { } }),
+    },
+    watch: () => ({ on: () => { }, close: async () => { } }),
+}));
+vi.mock("./sqlite-vec.js", () => ({
+    loadSqliteVecExtension: async () => ({ ok: false, error: "sqlite-vec disabled in tests" }),
+}));

package/dist/node-host/invoke-browser.js

@@ -0,0 +1,177 @@
+import fsPromises from "node:fs/promises";
+import { resolveBrowserConfig } from "../browser/config.js";
+import { createBrowserControlContext, startBrowserControlServiceFromConfig, } from "../browser/control-service.js";
+import { createBrowserRouteDispatcher } from "../browser/routes/dispatcher.js";
+import { loadConfig } from "../config/config.js";
+import { detectMime } from "../media/mime.js";
+import { withTimeout } from "./with-timeout.js";
+const BROWSER_PROXY_MAX_FILE_BYTES = 10 * 1024 * 1024;
+function normalizeProfileAllowlist(raw) {
+    return Array.isArray(raw) ? raw.map((entry) => entry.trim()).filter(Boolean) : [];
+}
+function resolveBrowserProxyConfig() {
+    const cfg = loadConfig();
+    const proxy = cfg.nodeHost?.browserProxy;
+    const allowProfiles = normalizeProfileAllowlist(proxy?.allowProfiles);
+    const enabled = proxy?.enabled !== false;
+    return { enabled, allowProfiles };
+}
+let browserControlReady = null;
+async function ensureBrowserControlService() {
+    if (browserControlReady) {
+        return browserControlReady;
+    }
+    browserControlReady = (async () => {
+        const cfg = loadConfig();
+        const resolved = resolveBrowserConfig(cfg.browser, cfg);
+        if (!resolved.enabled) {
+            throw new Error("browser control disabled");
+        }
+        const started = await startBrowserControlServiceFromConfig();
+        if (!started) {
+            throw new Error("browser control disabled");
+        }
+    })();
+    return browserControlReady;
+}
+function isProfileAllowed(params) {
+    const { allowProfiles, profile } = params;
+    if (!allowProfiles.length) {
+        return true;
+    }
+    if (!profile) {
+        return false;
+    }
+    return allowProfiles.includes(profile.trim());
+}
+function collectBrowserProxyPaths(payload) {
+    const paths = new Set();
+    const obj = typeof payload === "object" && payload !== null ? payload : null;
+    if (!obj) {
+        return [];
+    }
+    if (typeof obj.path === "string" && obj.path.trim()) {
+        paths.add(obj.path.trim());
+    }
+    if (typeof obj.imagePath === "string" && obj.imagePath.trim()) {
+        paths.add(obj.imagePath.trim());
+    }
+    const download = obj.download;
+    if (download && typeof download === "object") {
+        const dlPath = download.path;
+        if (typeof dlPath === "string" && dlPath.trim()) {
+            paths.add(dlPath.trim());
+        }
+    }
+    return [...paths];
+}
+async function readBrowserProxyFile(filePath) {
+    const stat = await fsPromises.stat(filePath).catch(() => null);
+    if (!stat || !stat.isFile()) {
+        return null;
+    }
+    if (stat.size > BROWSER_PROXY_MAX_FILE_BYTES) {
+        throw new Error(`browser proxy file exceeds ${Math.round(BROWSER_PROXY_MAX_FILE_BYTES / (1024 * 1024))}MB`);
+    }
+    const buffer = await fsPromises.readFile(filePath);
+    const mimeType = await detectMime({ buffer, filePath });
+    return { path: filePath, base64: buffer.toString("base64"), mimeType };
+}
+function decodeParams(raw) {
+    if (!raw) {
+        throw new Error("INVALID_REQUEST: paramsJSON required");
+    }
+    return JSON.parse(raw);
+}
+export async function runBrowserProxyCommand(paramsJSON) {
+    const params = decodeParams(paramsJSON);
+    const pathValue = typeof params.path === "string" ? params.path.trim() : "";
+    if (!pathValue) {
+        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 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;
+    }
+    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 dispatcher = createBrowserRouteDispatcher(createBrowserControlContext());
+    const response = await withTimeout((signal) => dispatcher.dispatch({
+        method: method === "DELETE" ? "DELETE" : method === "POST" ? "POST" : "GET",
+        path,
+        query,
+        body,
+        signal,
+    }), 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);
+    }
+    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);
+        });
+    }
+    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,
+                });
+            }
+        }));
+        if (loaded.length > 0) {
+            files = loaded;
+        }
+    }
+    const payload = files ? { result, files } : { result };
+    return JSON.stringify(payload);
+}