@poolzin/pool-bot 2026.2.17 → 2026.2.18

package/dist/memory/qmd-query-parser.js

@@ -0,0 +1,107 @@
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("memory");
+export function parseQmdQueryJson(stdout, stderr) {
+    const trimmedStdout = stdout.trim();
+    const trimmedStderr = stderr.trim();
+    const stdoutIsMarker = trimmedStdout.length > 0 && isQmdNoResultsOutput(trimmedStdout);
+    const stderrIsMarker = trimmedStderr.length > 0 && isQmdNoResultsOutput(trimmedStderr);
+    if (stdoutIsMarker || (!trimmedStdout && stderrIsMarker)) {
+        return [];
+    }
+    if (!trimmedStdout) {
+        const context = trimmedStderr ? ` (stderr: ${summarizeQmdStderr(trimmedStderr)})` : "";
+        const message = `stdout empty${context}`;
+        log.warn(`qmd query returned invalid JSON: ${message}`);
+        throw new Error(`qmd query returned invalid JSON: ${message}`);
+    }
+    try {
+        const parsed = parseQmdQueryResultArray(trimmedStdout);
+        if (parsed !== null) {
+            return parsed;
+        }
+        const noisyPayload = extractFirstJsonArray(trimmedStdout);
+        if (!noisyPayload) {
+            throw new Error("qmd query JSON response was not an array");
+        }
+        const fallback = parseQmdQueryResultArray(noisyPayload);
+        if (fallback !== null) {
+            return fallback;
+        }
+        throw new Error("qmd query JSON response was not an array");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log.warn(`qmd query returned invalid JSON: ${message}`);
+        throw new Error(`qmd query returned invalid JSON: ${message}`, { cause: err });
+    }
+}
+function isQmdNoResultsOutput(raw) {
+    const lines = raw
+        .split(/\r?\n/)
+        .map((line) => line.trim().toLowerCase().replace(/\s+/g, " "))
+        .filter((line) => line.length > 0);
+    return lines.some((line) => isQmdNoResultsLine(line));
+}
+function isQmdNoResultsLine(line) {
+    if (line === "no results found" || line === "no results found.") {
+        return true;
+    }
+    return /^(?:\[[^\]]+\]\s*)?(?:(?:warn(?:ing)?|info|error|qmd)\s*:\s*)+no results found\.?$/.test(line);
+}
+function summarizeQmdStderr(raw) {
+    return raw.length <= 120 ? raw : `${raw.slice(0, 117)}...`;
+}
+function parseQmdQueryResultArray(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function extractFirstJsonArray(raw) {
+    const start = raw.indexOf("[");
+    if (start < 0) {
+        return null;
+    }
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < raw.length; i += 1) {
+        const char = raw[i];
+        if (char === undefined) {
+            break;
+        }
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === "[") {
+            depth += 1;
+        }
+        else if (char === "]") {
+            depth -= 1;
+            if (depth === 0) {
+                return raw.slice(start, i + 1);
+            }
+        }
+    }
+    return null;
+}

package/dist/memory/qmd-scope.js

@@ -0,0 +1,93 @@
+import { parseAgentSessionKey } from "../sessions/session-key-utils.js";
+export function isQmdScopeAllowed(scope, sessionKey) {
+    if (!scope) {
+        return true;
+    }
+    const parsed = parseQmdSessionScope(sessionKey);
+    const channel = parsed.channel;
+    const chatType = parsed.chatType;
+    const normalizedKey = parsed.normalizedKey ?? "";
+    const rawKey = sessionKey?.trim().toLowerCase() ?? "";
+    for (const rule of scope.rules ?? []) {
+        if (!rule) {
+            continue;
+        }
+        const match = rule.match ?? {};
+        if (match.channel && match.channel !== channel) {
+            continue;
+        }
+        if (match.chatType && match.chatType !== chatType) {
+            continue;
+        }
+        const normalizedPrefix = match.keyPrefix?.trim().toLowerCase() || undefined;
+        const rawPrefix = match.keyPrefix?.trim().toLowerCase() || undefined;
+        if (rawPrefix && !rawKey.startsWith(rawPrefix)) {
+            continue;
+        }
+        if (normalizedPrefix) {
+            // Backward compat: older configs used `keyPrefix: "agent:<id>:..."` to match raw keys.
+            const isLegacyRaw = normalizedPrefix.startsWith("agent:");
+            if (isLegacyRaw) {
+                if (!rawKey.startsWith(normalizedPrefix)) {
+                    continue;
+                }
+            }
+            else if (!normalizedKey.startsWith(normalizedPrefix)) {
+                continue;
+            }
+        }
+        return rule.action === "allow";
+    }
+    const fallback = scope.default ?? "allow";
+    return fallback === "allow";
+}
+export function deriveQmdScopeChannel(key) {
+    return parseQmdSessionScope(key).channel;
+}
+export function deriveQmdScopeChatType(key) {
+    return parseQmdSessionScope(key).chatType;
+}
+function parseQmdSessionScope(key) {
+    const normalized = normalizeQmdSessionKey(key);
+    if (!normalized) {
+        return {};
+    }
+    const parts = normalized.split(":").filter(Boolean);
+    let chatType;
+    if (parts.length >= 2 &&
+        (parts[1] === "group" || parts[1] === "channel" || parts[1] === "direct" || parts[1] === "dm")) {
+        if (parts.includes("group")) {
+            chatType = "group";
+        }
+        else if (parts.includes("channel")) {
+            chatType = "channel";
+        }
+        return {
+            normalizedKey: normalized,
+            channel: parts[0]?.toLowerCase(),
+            chatType: chatType ?? "direct",
+        };
+    }
+    if (normalized.includes(":group:")) {
+        return { normalizedKey: normalized, chatType: "group" };
+    }
+    if (normalized.includes(":channel:")) {
+        return { normalizedKey: normalized, chatType: "channel" };
+    }
+    return { normalizedKey: normalized, chatType: "direct" };
+}
+function normalizeQmdSessionKey(key) {
+    if (!key) {
+        return undefined;
+    }
+    const trimmed = key.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const parsed = parseAgentSessionKey(trimmed);
+    const normalized = (parsed?.rest ?? trimmed).toLowerCase();
+    if (normalized.startsWith("subagent:")) {
+        return undefined;
+    }
+    return normalized;
+}

package/dist/memory/search-manager.js

@@ -11,7 +11,6 @@ export async function getMemorySearchManager(params) {
             return { manager: cached };
         }
         try {
-            // @ts-expect-error qmd-manager is an optional module that may not exist at build time
             const { QmdMemoryManager } = await import("./qmd-manager.js");
             const primary = await QmdMemoryManager.create({
                 cfg: params.cfg,

package/dist/memory/sync-index.js

@@ -0,0 +1,21 @@
+function tickProgress(progress) {
+    if (!progress) {
+        return;
+    }
+    progress.completed += 1;
+    progress.report({
+        completed: progress.completed,
+        total: progress.total,
+    });
+}
+export async function indexFileEntryIfChanged(params) {
+    const record = params.db
+        .prepare(`SELECT hash FROM files WHERE path = ? AND source = ?`)
+        .get(params.entry.path, params.source);
+    if (!params.needsFullReindex && record?.hash === params.entry.hash) {
+        tickProgress(params.progress);
+        return;
+    }
+    await params.indexFile(params.entry);
+    tickProgress(params.progress);
+}

package/dist/memory/sync-progress.js

@@ -0,0 +1,22 @@
+export function bumpSyncProgressTotal(progress, delta, label) {
+    if (!progress) {
+        return;
+    }
+    progress.total += delta;
+    progress.report({
+        completed: progress.completed,
+        total: progress.total,
+        label,
+    });
+}
+export function bumpSyncProgressCompleted(progress, delta = 1, label) {
+    if (!progress) {
+        return;
+    }
+    progress.completed += delta;
+    progress.report({
+        completed: progress.completed,
+        total: progress.total,
+        label,
+    });
+}

package/dist/memory/sync-stale.js

@@ -0,0 +1,30 @@
+export function deleteStaleIndexedPaths(params) {
+    const staleRows = params.db
+        .prepare(`SELECT path FROM files WHERE source = ?`)
+        .all(params.source);
+    for (const stale of staleRows) {
+        if (params.activePaths.has(stale.path)) {
+            continue;
+        }
+        params.db
+            .prepare(`DELETE FROM files WHERE path = ? AND source = ?`)
+            .run(stale.path, params.source);
+        try {
+            params.db
+                .prepare(`DELETE FROM ${params.vectorTable} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`)
+                .run(stale.path, params.source);
+        }
+        catch { }
+        params.db
+            .prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`)
+            .run(stale.path, params.source);
+        if (params.ftsEnabled && params.ftsAvailable) {
+            try {
+                params.db
+                    .prepare(`DELETE FROM ${params.ftsTable} WHERE path = ? AND source = ? AND model = ?`)
+                    .run(stale.path, params.source, params.model);
+            }
+            catch { }
+        }
+    }
+}

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);
+}