@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/utils.js

@@ -1,288 +1,22 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { resolveOAuthDir } from "./config/paths.js";
-import { logVerbose, shouldLogVerbose } from "./globals.js";
-import { expandHomePrefix, resolveEffectiveHomeDir, resolveRequiredHomeDir, } from "./infra/home-dir.js";
-export async function ensureDir(dir) {
-    await fs.promises.mkdir(dir, { recursive: true });
-}
-/**
- * Check if a file or directory exists at the given path.
- */
-export async function pathExists(targetPath) {
-    try {
-        await fs.promises.access(targetPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function clampNumber(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-}
-export function clampInt(value, min, max) {
-    return clampNumber(Math.floor(value), min, max);
-}
-/** Alias for clampNumber (shorter, more common name) */
-export const clamp = clampNumber;
-/**
- * Escapes special regex characters in a string so it can be used in a RegExp constructor.
- */
-export function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-/**
- * Safely parse JSON, returning null on error instead of throwing.
- */
-export function safeParseJson(raw) {
+// Stub for utils.js
+export function safeParseJson(str) {
     try {
-        return JSON.parse(raw);
+        return JSON.parse(str);
     }
     catch {
         return null;
     }
 }
-/**
- * Type guard for Record<string, unknown> (less strict than isPlainObject).
- * Accepts any non-null object that isn't an array.
- */
-export function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export function assertWebChannel(input) {
-    if (input !== "web") {
-        throw new Error("Web channel must be 'web'");
-    }
-}
-export function normalizePath(p) {
-    if (!p.startsWith("/"))
-        return `/${p}`;
-    return p;
-}
-export function withWhatsAppPrefix(number) {
-    return number.startsWith("whatsapp:") ? number : `whatsapp:${number}`;
-}
-export function normalizeE164(number) {
-    const withoutPrefix = number.replace(/^whatsapp:/, "").trim();
-    const digits = withoutPrefix.replace(/[^\d+]/g, "");
-    if (digits.startsWith("+"))
-        return `+${digits.slice(1)}`;
-    return `+${digits}`;
-}
-/**
- * "Self-chat mode" heuristic (single phone): the gateway is logged in as the owner's own WhatsApp account,
- * and `channels.whatsapp.allowFrom` includes that same number. Used to avoid side-effects that make no sense when the
- * "bot" and the human are the same WhatsApp identity (e.g. auto read receipts, @mention JID triggers).
- */
-export function isSelfChatMode(selfE164, allowFrom) {
-    if (!selfE164)
-        return false;
-    if (!Array.isArray(allowFrom) || allowFrom.length === 0)
-        return false;
-    const normalizedSelf = normalizeE164(selfE164);
-    return allowFrom.some((n) => {
-        if (n === "*")
-            return false;
-        try {
-            return normalizeE164(String(n)) === normalizedSelf;
-        }
-        catch {
-            return false;
-        }
-    });
-}
-export function toWhatsappJid(number) {
-    const withoutPrefix = number.replace(/^whatsapp:/, "").trim();
-    if (withoutPrefix.includes("@"))
-        return withoutPrefix;
-    const e164 = normalizeE164(withoutPrefix);
-    const digits = e164.replace(/\D/g, "");
-    return `${digits}@s.whatsapp.net`;
-}
-function resolveLidMappingDirs(opts) {
-    const dirs = new Set();
-    const addDir = (dir) => {
-        if (!dir)
-            return;
-        dirs.add(resolveUserPath(dir));
-    };
-    addDir(opts?.authDir);
-    for (const dir of opts?.lidMappingDirs ?? [])
-        addDir(dir);
-    addDir(resolveOAuthDir());
-    addDir(path.join(CONFIG_DIR, "credentials"));
-    return [...dirs];
-}
-function readLidReverseMapping(lid, opts) {
-    const mappingFilename = `lid-mapping-${lid}_reverse.json`;
-    const mappingDirs = resolveLidMappingDirs(opts);
-    for (const dir of mappingDirs) {
-        const mappingPath = path.join(dir, mappingFilename);
-        try {
-            const data = fs.readFileSync(mappingPath, "utf8");
-            const phone = JSON.parse(data);
-            if (phone === null || phone === undefined)
-                continue;
-            return normalizeE164(String(phone));
-        }
-        catch {
-            // Try the next location.
-        }
-    }
-    return null;
-}
-export function jidToE164(jid, opts) {
-    // Convert a WhatsApp JID (with optional device suffix, e.g. 1234:1@s.whatsapp.net) back to +1234.
-    const match = jid.match(/^(\d+)(?::\d+)?@(s\.whatsapp\.net|hosted)$/);
-    if (match) {
-        const digits = match[1];
-        return `+${digits}`;
-    }
-    // Support @lid format (WhatsApp Linked ID) - look up reverse mapping
-    const lidMatch = jid.match(/^(\d+)(?::\d+)?@(lid|hosted\.lid)$/);
-    if (lidMatch) {
-        const lid = lidMatch[1];
-        const phone = readLidReverseMapping(lid, opts);
-        if (phone)
-            return phone;
-        const shouldLog = opts?.logMissing ?? shouldLogVerbose();
-        if (shouldLog) {
-            logVerbose(`LID mapping not found for ${lid}; skipping inbound message`);
-        }
-    }
-    return null;
-}
-export async function resolveJidToE164(jid, opts) {
-    if (!jid)
-        return null;
-    const direct = jidToE164(jid, opts);
-    if (direct)
-        return direct;
-    if (!/(@lid|@hosted\.lid)$/.test(jid))
-        return null;
-    if (!opts?.lidLookup?.getPNForLID)
-        return null;
-    try {
-        const pnJid = await opts.lidLookup.getPNForLID(jid);
-        if (!pnJid)
-            return null;
-        return jidToE164(pnJid, opts);
-    }
-    catch (err) {
-        if (shouldLogVerbose()) {
-            logVerbose(`LID mapping lookup failed for ${jid}: ${String(err)}`);
-        }
-        return null;
-    }
-}
 export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function isHighSurrogate(codeUnit) {
-    return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
-}
-function isLowSurrogate(codeUnit) {
-    return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
+export function stripAnsi(str) {
+    // oxlint-disable-next-line no-control-regex
+    return str.replace(/\u001b\[[0-9;]*m/g, "");
 }
-export function sliceUtf16Safe(input, start, end) {
-    const len = input.length;
-    let from = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
-    let to = end === undefined ? len : end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
-    if (to < from) {
-        const tmp = from;
-        from = to;
-        to = tmp;
-    }
-    if (from > 0 && from < len) {
-        const codeUnit = input.charCodeAt(from);
-        if (isLowSurrogate(codeUnit) && isHighSurrogate(input.charCodeAt(from - 1))) {
-            from += 1;
-        }
-    }
-    if (to > 0 && to < len) {
-        const codeUnit = input.charCodeAt(to - 1);
-        if (isHighSurrogate(codeUnit) && isLowSurrogate(input.charCodeAt(to))) {
-            to -= 1;
-        }
-    }
-    return input.slice(from, to);
-}
-export function truncateUtf16Safe(input, maxLen) {
-    const limit = Math.max(0, Math.floor(maxLen));
-    if (input.length <= limit)
-        return input;
-    return sliceUtf16Safe(input, 0, limit);
-}
-export function resolveUserPath(input) {
-    const trimmed = input.trim();
-    if (!trimmed)
-        return trimmed;
-    if (trimmed.startsWith("~")) {
-        const expanded = expandHomePrefix(trimmed, {
-            home: resolveRequiredHomeDir(process.env, os.homedir),
-            env: process.env,
-            homedir: os.homedir,
-        });
-        return path.resolve(expanded);
-    }
-    return path.resolve(trimmed);
-}
-export function resolveConfigDir(env = process.env, homedir = os.homedir) {
-    const override = env.POOLBOT_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
-    if (override)
-        return resolveUserPath(override);
-    return path.join(homedir(), ".poolbot");
-}
-export function resolveHomeDir() {
-    return resolveEffectiveHomeDir(process.env, os.homedir);
-}
-export function shortenHomePath(input) {
-    if (!input)
-        return input;
-    const home = resolveHomeDir();
-    if (!home)
-        return input;
-    if (input === home)
-        return "~";
-    if (input.startsWith(`${home}/`))
-        return `~${input.slice(home.length)}`;
-    return input;
-}
-export function shortenHomeInString(input) {
-    if (!input)
-        return input;
-    const home = resolveHomeDir();
-    if (!home)
-        return input;
-    return input.split(home).join("~");
-}
-export function displayPath(input) {
-    return shortenHomePath(input);
-}
-export function displayString(input) {
-    return shortenHomeInString(input);
-}
-export function formatTerminalLink(label, url, opts) {
-    const esc = "\u001b";
-    const safeLabel = label.replaceAll(esc, "");
-    const safeUrl = url.replaceAll(esc, "");
-    const allow = opts?.force === true ? true : opts?.force === false ? false : Boolean(process.stdout.isTTY);
-    if (!allow) {
-        return opts?.fallback ?? `${safeLabel} (${safeUrl})`;
-    }
-    return `\u001b]8;;${safeUrl}\u0007${safeLabel}\u001b]8;;\u0007`;
+export function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-/**
- * Strict plain-object check — returns true only for `Object.create(null)` or `{}` literals.
- * Arrays, Dates, RegExps, class instances, and null/undefined all return false.
- */
-export function isPlainObject(value) {
-    if (typeof value !== "object" || value === null)
-        return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || proto === null;
+export function clamp(val, min, max) {
+    return Math.min(max, Math.max(min, val));
 }
-// Configuration root; can be overridden via POOLBOT_STATE_DIR (or CLAWDBOT_STATE_DIR).
-export const CONFIG_DIR = resolveConfigDir();

package/dist/wizard/prompts.js

@@ -1,6 +1,6 @@
-export class WizardCancelledError extends Error {
-    constructor(message = "wizard cancelled") {
-        super(message);
-        this.name = "WizardCancelledError";
-    }
+export async function promptAccountId(_config, _channelKey) {
+    return "default";
+}
+export async function promptChannelAccessConfig(_config, _channelKey, _accountId) {
+    return {};
 }

package/extensions/feishu/src/policy.ts

@@ -38,7 +38,7 @@ export function resolveFeishuGroupConfig(params: {
 
 export function resolveFeishuGroupToolPolicy(
   params: ChannelGroupContext,
-): GroupToolPolicyConfig | undefined {
+): GroupToolPolicyConfig? {
   const cfg = params.cfg.channels?.feishu as FeishuConfig | undefined;
   if (!cfg) {
     return undefined;

package/extensions/firecrawl/index.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import plugin from "./index.js";
+import { __testing as firecrawlClientTesting } from "./src/firecrawl-client.js";
+
+describe("firecrawl plugin", () => {
+  it("parses scrape payloads into wrapped external-content results", () => {
+    const result = firecrawlClientTesting.parseFirecrawlScrapePayload({
+      payload: {
+        success: true,
+        data: {
+          markdown: "# Hello\n\nWorld",
+          metadata: {
+            title: "Example page",
+            sourceURL: "https://example.com/final",
+            statusCode: 200,
+          },
+        },
+      },
+      url: "https://example.com/start",
+      extractMode: "text",
+      maxChars: 1000,
+    });
+
+    expect(result.finalUrl).toBe("https://example.com/final");
+    expect(result.status).toBe(200);
+    expect(result.extractor).toBe("firecrawl");
+    expect(typeof result.text).toBe("string");
+  });
+
+  it("extracts search items from flexible Firecrawl payload shapes", () => {
+    const items = firecrawlClientTesting.resolveSearchItems({
+      success: true,
+      data: [
+        {
+          title: "Docs",
+          url: "https://docs.example.com/path",
+          description: "Reference docs",
+          markdown: "Body",
+        },
+      ],
+    });
+
+    expect(items).toEqual([
+      {
+        title: "Docs",
+        url: "https://docs.example.com/path",
+        description: "Reference docs",
+        content: "Body",
+        published: undefined,
+        siteName: "docs.example.com",
+      },
+    ]);
+  });
+
+  it("extracts search items from Firecrawl v2 data.web payloads", () => {
+    const items = firecrawlClientTesting.resolveSearchItems({
+      success: true,
+      data: {
+        web: [
+          {
+            title: "API Platform - OpenAI",
+            url: "https://openai.com/api/",
+            description: "Build on the OpenAI API platform.",
+            markdown: "# API Platform",
+            position: 1,
+          },
+        ],
+      },
+    });
+
+    expect(items).toEqual([
+      {
+        title: "API Platform - OpenAI",
+        url: "https://openai.com/api/",
+        description: "Build on the OpenAI API platform.",
+        content: "# API Platform",
+        published: undefined,
+        siteName: "openai.com",
+      },
+    ]);
+  });
+});

package/extensions/firecrawl/index.ts

@@ -0,0 +1,20 @@
+import type { AnyAgentTool } from "../../src/agents/tools/common.js";
+import { emptyPluginConfigSchema } from "../../src/plugins/config-schema.js";
+import type { OpenClawPluginApi } from "../../src/plugins/types.js";
+import { createFirecrawlScrapeTool } from "./src/firecrawl-scrape-tool.js";
+import { createFirecrawlWebSearchProvider } from "./src/firecrawl-search-provider.js";
+import { createFirecrawlSearchTool } from "./src/firecrawl-search-tool.js";
+
+const firecrawlPlugin = {
+  id: "firecrawl",
+  name: "Firecrawl Plugin",
+  description: "Bundled Firecrawl search and scrape plugin",
+  configSchema: emptyPluginConfigSchema(),
+  register(api: OpenClawPluginApi) {
+    api.registerWebSearchProvider(createFirecrawlWebSearchProvider());
+    api.registerTool(createFirecrawlSearchTool(api) as AnyAgentTool);
+    api.registerTool(createFirecrawlScrapeTool(api) as AnyAgentTool);
+  },
+};
+
+export default firecrawlPlugin;

package/extensions/firecrawl/openclaw.plugin.json

@@ -0,0 +1,8 @@
+{
+  "id": "firecrawl",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/extensions/firecrawl/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@openclaw/firecrawl-plugin",
+  "version": "2026.3.14",
+  "private": true,
+  "description": "OpenClaw Firecrawl plugin",
+  "type": "module",
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/extensions/firecrawl/src/config.ts

@@ -0,0 +1,159 @@
+import type { OpenClawConfig } from "../../../src/config/config.js";
+import { normalizeResolvedSecretInputString } from "../../../src/config/types.secrets.js";
+import { normalizeSecretInput } from "../../../src/utils/normalize-secret-input.js";
+
+export const DEFAULT_FIRECRAWL_BASE_URL = "https://api.firecrawl.dev";
+export const DEFAULT_FIRECRAWL_SEARCH_TIMEOUT_SECONDS = 30;
+export const DEFAULT_FIRECRAWL_SCRAPE_TIMEOUT_SECONDS = 60;
+export const DEFAULT_FIRECRAWL_MAX_AGE_MS = 172_800_000;
+
+type WebSearchConfig = NonNullable<OpenClawConfig["tools"]>["web"] extends infer Web
+  ? Web extends { search?: infer Search }
+    ? Search
+    : undefined
+  : undefined;
+
+type WebFetchConfig = NonNullable<OpenClawConfig["tools"]>["web"] extends infer Web
+  ? Web extends { fetch?: infer Fetch }
+    ? Fetch
+    : undefined
+  : undefined;
+
+type FirecrawlSearchConfig =
+  | {
+      apiKey?: unknown;
+      baseUrl?: string;
+    }
+  | undefined;
+
+type FirecrawlFetchConfig =
+  | {
+      apiKey?: unknown;
+      baseUrl?: string;
+      onlyMainContent?: boolean;
+      maxAgeMs?: number;
+      timeoutSeconds?: number;
+    }
+  | undefined;
+
+function resolveSearchConfig(cfg?: OpenClawConfig): WebSearchConfig {
+  const search = cfg?.tools?.web?.search;
+  if (!search || typeof search !== "object") {
+    return undefined;
+  }
+  return search as WebSearchConfig;
+}
+
+function resolveFetchConfig(cfg?: OpenClawConfig): WebFetchConfig {
+  const fetch = cfg?.tools?.web?.fetch;
+  if (!fetch || typeof fetch !== "object") {
+    return undefined;
+  }
+  return fetch as WebFetchConfig;
+}
+
+export function resolveFirecrawlSearchConfig(cfg?: OpenClawConfig): FirecrawlSearchConfig {
+  const search = resolveSearchConfig(cfg);
+  if (!search || typeof search !== "object") {
+    return undefined;
+  }
+  const firecrawl = "firecrawl" in search ? search.firecrawl : undefined;
+  if (!firecrawl || typeof firecrawl !== "object") {
+    return undefined;
+  }
+  return firecrawl as FirecrawlSearchConfig;
+}
+
+export function resolveFirecrawlFetchConfig(cfg?: OpenClawConfig): FirecrawlFetchConfig {
+  const fetch = resolveFetchConfig(cfg);
+  if (!fetch || typeof fetch !== "object") {
+    return undefined;
+  }
+  const firecrawl = "firecrawl" in fetch ? fetch.firecrawl : undefined;
+  if (!firecrawl || typeof firecrawl !== "object") {
+    return undefined;
+  }
+  return firecrawl as FirecrawlFetchConfig;
+}
+
+function normalizeConfiguredSecret(value: unknown, path: string): string | undefined {
+  return normalizeSecretInput(
+    normalizeResolvedSecretInputString({
+      value,
+      path,
+    }),
+  );
+}
+
+export function resolveFirecrawlApiKey(cfg?: OpenClawConfig): string | undefined {
+  const search = resolveFirecrawlSearchConfig(cfg);
+  const fetch = resolveFirecrawlFetchConfig(cfg);
+  return (
+    normalizeConfiguredSecret(search?.apiKey, "tools.web.search.firecrawl.apiKey") ||
+    normalizeConfiguredSecret(fetch?.apiKey, "tools.web.fetch.firecrawl.apiKey") ||
+    normalizeSecretInput(process.env.FIRECRAWL_API_KEY) ||
+    undefined
+  );
+}
+
+export function resolveFirecrawlBaseUrl(cfg?: OpenClawConfig): string {
+  const search = resolveFirecrawlSearchConfig(cfg);
+  const fetch = resolveFirecrawlFetchConfig(cfg);
+  const configured =
+    (typeof search?.baseUrl === "string" ? search.baseUrl.trim() : "") ||
+    (typeof fetch?.baseUrl === "string" ? fetch.baseUrl.trim() : "") ||
+    normalizeSecretInput(process.env.FIRECRAWL_BASE_URL) ||
+    "";
+  return configured || DEFAULT_FIRECRAWL_BASE_URL;
+}
+
+export function resolveFirecrawlOnlyMainContent(cfg?: OpenClawConfig, override?: boolean): boolean {
+  if (typeof override === "boolean") {
+    return override;
+  }
+  const fetch = resolveFirecrawlFetchConfig(cfg);
+  if (typeof fetch?.onlyMainContent === "boolean") {
+    return fetch.onlyMainContent;
+  }
+  return true;
+}
+
+export function resolveFirecrawlMaxAgeMs(cfg?: OpenClawConfig, override?: number): number {
+  if (typeof override === "number" && Number.isFinite(override) && override >= 0) {
+    return Math.floor(override);
+  }
+  const fetch = resolveFirecrawlFetchConfig(cfg);
+  if (
+    typeof fetch?.maxAgeMs === "number" &&
+    Number.isFinite(fetch.maxAgeMs) &&
+    fetch.maxAgeMs >= 0
+  ) {
+    return Math.floor(fetch.maxAgeMs);
+  }
+  return DEFAULT_FIRECRAWL_MAX_AGE_MS;
+}
+
+export function resolveFirecrawlScrapeTimeoutSeconds(
+  cfg?: OpenClawConfig,
+  override?: number,
+): number {
+  if (typeof override === "number" && Number.isFinite(override) && override > 0) {
+    return Math.floor(override);
+  }
+  const fetch = resolveFirecrawlFetchConfig(cfg);
+  if (
+    typeof fetch?.timeoutSeconds === "number" &&
+    Number.isFinite(fetch.timeoutSeconds) &&
+    fetch.timeoutSeconds > 0
+  ) {
+    return Math.floor(fetch.timeoutSeconds);
+  }
+  return DEFAULT_FIRECRAWL_SCRAPE_TIMEOUT_SECONDS;
+}
+
+export function resolveFirecrawlSearchTimeoutSeconds(override?: number): number {
+  if (typeof override === "number" && Number.isFinite(override) && override > 0) {
+    return Math.floor(override);
+  }
+  return DEFAULT_FIRECRAWL_SEARCH_TIMEOUT_SECONDS;
+}