@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/dist/plugin-sdk/slack-message-actions.js

@@ -0,0 +1,133 @@
+import { readNumberParam, readStringParam } from "../agents/tools/common.js";
+import { parseSlackBlocksInput } from "../slack/blocks-input.js";
+function readSlackBlocksParam(actionParams) {
+    return parseSlackBlocksInput(actionParams.blocks);
+}
+export async function handleSlackMessageAction(params) {
+    const { providerId, ctx, invoke, normalizeChannelId, includeReadThreadId = false } = params;
+    const { action, cfg, params: actionParams } = ctx;
+    const accountId = ctx.accountId ?? undefined;
+    const resolveChannelId = () => {
+        const channelId = readStringParam(actionParams, "channelId") ??
+            readStringParam(actionParams, "to", { required: true });
+        return normalizeChannelId ? normalizeChannelId(channelId) : channelId;
+    };
+    if (action === "send") {
+        const to = readStringParam(actionParams, "to", { required: true });
+        const content = readStringParam(actionParams, "message", {
+            required: false,
+            allowEmpty: true,
+        });
+        const mediaUrl = readStringParam(actionParams, "media", { trim: false });
+        const blocks = readSlackBlocksParam(actionParams);
+        if (!content && !mediaUrl && !blocks) {
+            throw new Error("Slack send requires message, blocks, or media.");
+        }
+        if (mediaUrl && blocks) {
+            throw new Error("Slack send does not support blocks with media.");
+        }
+        const threadId = readStringParam(actionParams, "threadId");
+        const replyTo = readStringParam(actionParams, "replyTo");
+        return await invoke({
+            action: "sendMessage",
+            to,
+            content: content ?? "",
+            mediaUrl: mediaUrl ?? undefined,
+            blocks,
+            accountId,
+            threadTs: threadId ?? replyTo ?? undefined,
+        }, cfg, ctx.toolContext);
+    }
+    if (action === "react") {
+        const messageId = readStringParam(actionParams, "messageId", {
+            required: true,
+        });
+        const emoji = readStringParam(actionParams, "emoji", { allowEmpty: true });
+        const remove = typeof actionParams.remove === "boolean" ? actionParams.remove : undefined;
+        return await invoke({
+            action: "react",
+            channelId: resolveChannelId(),
+            messageId,
+            emoji,
+            remove,
+            accountId,
+        }, cfg);
+    }
+    if (action === "reactions") {
+        const messageId = readStringParam(actionParams, "messageId", {
+            required: true,
+        });
+        const limit = readNumberParam(actionParams, "limit", { integer: true });
+        return await invoke({
+            action: "reactions",
+            channelId: resolveChannelId(),
+            messageId,
+            limit,
+            accountId,
+        }, cfg);
+    }
+    if (action === "read") {
+        const limit = readNumberParam(actionParams, "limit", { integer: true });
+        const readAction = {
+            action: "readMessages",
+            channelId: resolveChannelId(),
+            limit,
+            before: readStringParam(actionParams, "before"),
+            after: readStringParam(actionParams, "after"),
+            accountId,
+        };
+        if (includeReadThreadId) {
+            readAction.threadId = readStringParam(actionParams, "threadId");
+        }
+        return await invoke(readAction, cfg);
+    }
+    if (action === "edit") {
+        const messageId = readStringParam(actionParams, "messageId", {
+            required: true,
+        });
+        const content = readStringParam(actionParams, "message", { allowEmpty: true });
+        const blocks = readSlackBlocksParam(actionParams);
+        if (!content && !blocks) {
+            throw new Error("Slack edit requires message or blocks.");
+        }
+        return await invoke({
+            action: "editMessage",
+            channelId: resolveChannelId(),
+            messageId,
+            content: content ?? "",
+            blocks,
+            accountId,
+        }, cfg);
+    }
+    if (action === "delete") {
+        const messageId = readStringParam(actionParams, "messageId", {
+            required: true,
+        });
+        return await invoke({
+            action: "deleteMessage",
+            channelId: resolveChannelId(),
+            messageId,
+            accountId,
+        }, cfg);
+    }
+    if (action === "pin" || action === "unpin" || action === "list-pins") {
+        const messageId = action === "list-pins"
+            ? undefined
+            : readStringParam(actionParams, "messageId", { required: true });
+        return await invoke({
+            action: action === "pin" ? "pinMessage" : action === "unpin" ? "unpinMessage" : "listPins",
+            channelId: resolveChannelId(),
+            messageId,
+            accountId,
+        }, cfg);
+    }
+    if (action === "member-info") {
+        const userId = readStringParam(actionParams, "userId", { required: true });
+        return await invoke({ action: "memberInfo", userId, accountId }, cfg);
+    }
+    if (action === "emoji-list") {
+        const limit = readNumberParam(actionParams, "limit", { integer: true });
+        return await invoke({ action: "emojiList", limit, accountId }, cfg);
+    }
+    throw new Error(`Action ${action} is not supported for provider ${providerId}.`);
+}

package/dist/plugin-sdk/status-helpers.js

@@ -0,0 +1,35 @@
+export function createDefaultChannelRuntimeState(accountId, extra) {
+    return {
+        accountId,
+        running: false,
+        lastStartAt: null,
+        lastStopAt: null,
+        lastError: null,
+        ...(extra ?? {}),
+    };
+}
+export function buildBaseChannelStatusSummary(snapshot) {
+    return {
+        configured: snapshot.configured ?? false,
+        running: snapshot.running ?? false,
+        lastStartAt: snapshot.lastStartAt ?? null,
+        lastStopAt: snapshot.lastStopAt ?? null,
+        lastError: snapshot.lastError ?? null,
+    };
+}
+export function collectStatusIssuesFromLastError(channel, accounts) {
+    return accounts.flatMap((account) => {
+        const lastError = typeof account.lastError === "string" ? account.lastError.trim() : "";
+        if (!lastError) {
+            return [];
+        }
+        return [
+            {
+                channel,
+                accountId: account.accountId,
+                kind: "runtime",
+                message: `Channel error: ${lastError}`,
+            },
+        ];
+    });
+}

package/dist/plugin-sdk/text-chunking.js

@@ -0,0 +1,31 @@
+export function chunkTextForOutbound(text, limit) {
+    if (!text) {
+        return [];
+    }
+    if (limit <= 0 || text.length <= limit) {
+        return [text];
+    }
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > limit) {
+        const window = remaining.slice(0, limit);
+        const lastNewline = window.lastIndexOf("\n");
+        const lastSpace = window.lastIndexOf(" ");
+        let breakIdx = lastNewline > 0 ? lastNewline : lastSpace;
+        if (breakIdx <= 0) {
+            breakIdx = limit;
+        }
+        const rawChunk = remaining.slice(0, breakIdx);
+        const chunk = rawChunk.trimEnd();
+        if (chunk.length > 0) {
+            chunks.push(chunk);
+        }
+        const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+        const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+        remaining = remaining.slice(nextStart).trimStart();
+    }
+    if (remaining.length) {
+        chunks.push(remaining);
+    }
+    return chunks;
+}

package/dist/plugin-sdk/tool-send.js

@@ -0,0 +1,12 @@
+export function extractToolSend(args, expectedAction = "sendMessage") {
+    const action = typeof args.action === "string" ? args.action.trim() : "";
+    if (action !== expectedAction) {
+        return null;
+    }
+    const to = typeof args.to === "string" ? args.to : undefined;
+    if (!to) {
+        return null;
+    }
+    const accountId = typeof args.accountId === "string" ? args.accountId.trim() : undefined;
+    return { to, accountId };
+}

package/dist/plugin-sdk/webhook-path.js

@@ -0,0 +1,27 @@
+export function normalizeWebhookPath(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return "/";
+    }
+    const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    if (withSlash.length > 1 && withSlash.endsWith("/")) {
+        return withSlash.slice(0, -1);
+    }
+    return withSlash;
+}
+export function resolveWebhookPath(params) {
+    const trimmedPath = params.webhookPath?.trim();
+    if (trimmedPath) {
+        return normalizeWebhookPath(trimmedPath);
+    }
+    if (params.webhookUrl?.trim()) {
+        try {
+            const parsed = new URL(params.webhookUrl);
+            return normalizeWebhookPath(parsed.pathname || "/");
+        }
+        catch {
+            return null;
+        }
+    }
+    return params.defaultPath ?? null;
+}

package/dist/plugin-sdk/webhook-targets.js

@@ -0,0 +1,34 @@
+import { normalizeWebhookPath } from "./webhook-path.js";
+export function registerWebhookTarget(targetsByPath, target) {
+    const key = normalizeWebhookPath(target.path);
+    const normalizedTarget = { ...target, path: key };
+    const existing = targetsByPath.get(key) ?? [];
+    targetsByPath.set(key, [...existing, normalizedTarget]);
+    const unregister = () => {
+        const updated = (targetsByPath.get(key) ?? []).filter((entry) => entry !== normalizedTarget);
+        if (updated.length > 0) {
+            targetsByPath.set(key, updated);
+            return;
+        }
+        targetsByPath.delete(key);
+    };
+    return { target: normalizedTarget, unregister };
+}
+export function resolveWebhookTargets(req, targetsByPath) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const path = normalizeWebhookPath(url.pathname);
+    const targets = targetsByPath.get(path);
+    if (!targets || targets.length === 0) {
+        return null;
+    }
+    return { path, targets };
+}
+export function rejectNonPostWebhookRequest(req, res) {
+    if (req.method === "POST") {
+        return false;
+    }
+    res.statusCode = 405;
+    res.setHeader("Allow", "POST");
+    res.end("Method Not Allowed");
+    return true;
+}

package/dist/plugins/hooks.test-helpers.js

@@ -0,0 +1,21 @@
+export function createMockPluginRegistry(hooks) {
+    return {
+        hooks: hooks,
+        typedHooks: hooks.map((h) => ({
+            pluginId: "test-plugin",
+            hookName: h.hookName,
+            handler: h.handler,
+            priority: 0,
+            source: "test",
+        })),
+        tools: [],
+        httpHandlers: [],
+        httpRoutes: [],
+        channelRegistrations: [],
+        gatewayHandlers: {},
+        cliRegistrars: [],
+        services: [],
+        providers: [],
+        commands: [],
+    };
+}

package/dist/plugins/uninstall.js

@@ -0,0 +1,171 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { resolvePluginInstallDir } from "./install.js";
+import { defaultSlotIdForKey } from "./slots.js";
+export function resolveUninstallDirectoryTarget(params) {
+    if (!params.hasInstall) {
+        return null;
+    }
+    if (params.installRecord?.source === "path") {
+        return null;
+    }
+    let defaultPath;
+    try {
+        defaultPath = resolvePluginInstallDir(params.pluginId, params.extensionsDir);
+    }
+    catch {
+        return null;
+    }
+    const configuredPath = params.installRecord?.installPath;
+    if (!configuredPath) {
+        return defaultPath;
+    }
+    if (path.resolve(configuredPath) === path.resolve(defaultPath)) {
+        return configuredPath;
+    }
+    // Never trust configured installPath blindly for recursive deletes.
+    return defaultPath;
+}
+/**
+ * Remove plugin references from config (pure config mutation).
+ * Returns a new config with the plugin removed from entries, installs, allow, load.paths, and slots.
+ */
+export function removePluginFromConfig(cfg, pluginId) {
+    const actions = {
+        entry: false,
+        install: false,
+        allowlist: false,
+        loadPath: false,
+        memorySlot: false,
+    };
+    const pluginsConfig = cfg.plugins ?? {};
+    // Remove from entries
+    let entries = pluginsConfig.entries;
+    if (entries && pluginId in entries) {
+        const { [pluginId]: _, ...rest } = entries;
+        entries = Object.keys(rest).length > 0 ? rest : undefined;
+        actions.entry = true;
+    }
+    // Remove from installs
+    let installs = pluginsConfig.installs;
+    const installRecord = installs?.[pluginId];
+    if (installs && pluginId in installs) {
+        const { [pluginId]: _, ...rest } = installs;
+        installs = Object.keys(rest).length > 0 ? rest : undefined;
+        actions.install = true;
+    }
+    // Remove from allowlist
+    let allow = pluginsConfig.allow;
+    if (Array.isArray(allow) && allow.includes(pluginId)) {
+        allow = allow.filter((id) => id !== pluginId);
+        if (allow.length === 0) {
+            allow = undefined;
+        }
+        actions.allowlist = true;
+    }
+    // Remove linked path from load.paths (for source === "path" plugins)
+    let load = pluginsConfig.load;
+    if (installRecord?.source === "path" && installRecord.sourcePath) {
+        const sourcePath = installRecord.sourcePath;
+        const loadPaths = load?.paths;
+        if (Array.isArray(loadPaths) && loadPaths.includes(sourcePath)) {
+            const nextLoadPaths = loadPaths.filter((p) => p !== sourcePath);
+            load = nextLoadPaths.length > 0 ? { ...load, paths: nextLoadPaths } : undefined;
+            actions.loadPath = true;
+        }
+    }
+    // Reset memory slot if this plugin was selected
+    let slots = pluginsConfig.slots;
+    if (slots?.memory === pluginId) {
+        slots = {
+            ...slots,
+            memory: defaultSlotIdForKey("memory"),
+        };
+        actions.memorySlot = true;
+    }
+    if (slots && Object.keys(slots).length === 0) {
+        slots = undefined;
+    }
+    const newPlugins = {
+        ...pluginsConfig,
+        entries,
+        installs,
+        allow,
+        load,
+        slots,
+    };
+    // Clean up undefined properties from newPlugins
+    const cleanedPlugins = { ...newPlugins };
+    if (cleanedPlugins.entries === undefined) {
+        delete cleanedPlugins.entries;
+    }
+    if (cleanedPlugins.installs === undefined) {
+        delete cleanedPlugins.installs;
+    }
+    if (cleanedPlugins.allow === undefined) {
+        delete cleanedPlugins.allow;
+    }
+    if (cleanedPlugins.load === undefined) {
+        delete cleanedPlugins.load;
+    }
+    if (cleanedPlugins.slots === undefined) {
+        delete cleanedPlugins.slots;
+    }
+    const config = {
+        ...cfg,
+        plugins: Object.keys(cleanedPlugins).length > 0 ? cleanedPlugins : undefined,
+    };
+    return { config, actions };
+}
+/**
+ * Uninstall a plugin by removing it from config and optionally deleting installed files.
+ * Linked plugins (source === "path") never have their source directory deleted.
+ */
+export async function uninstallPlugin(params) {
+    const { config, pluginId, deleteFiles = true, extensionsDir } = params;
+    // Validate plugin exists
+    const hasEntry = pluginId in (config.plugins?.entries ?? {});
+    const hasInstall = pluginId in (config.plugins?.installs ?? {});
+    if (!hasEntry && !hasInstall) {
+        return { ok: false, error: `Plugin not found: ${pluginId}` };
+    }
+    const installRecord = config.plugins?.installs?.[pluginId];
+    const isLinked = installRecord?.source === "path";
+    // Remove from config
+    const { config: newConfig, actions: configActions } = removePluginFromConfig(config, pluginId);
+    const actions = {
+        ...configActions,
+        directory: false,
+    };
+    const warnings = [];
+    const deleteTarget = deleteFiles && !isLinked
+        ? resolveUninstallDirectoryTarget({
+            pluginId,
+            hasInstall,
+            installRecord,
+            extensionsDir,
+        })
+        : null;
+    // Delete installed directory if requested and safe.
+    if (deleteTarget) {
+        const existed = (await fs
+            .access(deleteTarget)
+            .then(() => true)
+            .catch(() => false)) ?? false;
+        try {
+            await fs.rm(deleteTarget, { recursive: true, force: true });
+            actions.directory = existed;
+        }
+        catch (error) {
+            warnings.push(`Failed to remove plugin directory ${deleteTarget}: ${error instanceof Error ? error.message : String(error)}`);
+            // Directory deletion failure is not fatal; config is the source of truth.
+        }
+    }
+    return {
+        ok: true,
+        config: newConfig,
+        pluginId,
+        actions,
+        warnings,
+    };
+}

package/dist/process/kill-tree.js

@@ -0,0 +1,98 @@
+import { spawn } from "node:child_process";
+const DEFAULT_GRACE_MS = 3000;
+const MAX_GRACE_MS = 60_000;
+/**
+ * Best-effort process-tree termination with graceful shutdown.
+ * - Windows: use taskkill /T to include descendants. Sends SIGTERM-equivalent
+ *   first (without /F), then force-kills if process survives.
+ * - Unix: send SIGTERM to process group first, wait grace period, then SIGKILL.
+ *
+ * This gives child processes a chance to clean up (close connections, remove
+ * temp files, terminate their own children) before being hard-killed.
+ */
+export function killProcessTree(pid, opts) {
+    if (!Number.isFinite(pid) || pid <= 0) {
+        return;
+    }
+    const graceMs = normalizeGraceMs(opts?.graceMs);
+    if (process.platform === "win32") {
+        killProcessTreeWindows(pid, graceMs);
+        return;
+    }
+    killProcessTreeUnix(pid, graceMs);
+}
+function normalizeGraceMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return DEFAULT_GRACE_MS;
+    }
+    return Math.max(0, Math.min(MAX_GRACE_MS, Math.floor(value)));
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function killProcessTreeUnix(pid, graceMs) {
+    // Step 1: Try graceful SIGTERM to process group
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch {
+        // Process group doesn't exist or we lack permission - try direct
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch {
+            // Already gone
+            return;
+        }
+    }
+    // Step 2: Wait grace period, then SIGKILL if still alive
+    setTimeout(() => {
+        if (isProcessAlive(-pid)) {
+            try {
+                process.kill(-pid, "SIGKILL");
+                return;
+            }
+            catch {
+                // Fall through to direct pid kill
+            }
+        }
+        if (!isProcessAlive(pid)) {
+            return;
+        }
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // Process exited between liveness check and kill
+        }
+    }, graceMs).unref(); // Don't block event loop exit
+}
+function runTaskkill(args) {
+    try {
+        spawn("taskkill", args, {
+            stdio: "ignore",
+            detached: true,
+        });
+    }
+    catch {
+        // Ignore taskkill spawn failures
+    }
+}
+function killProcessTreeWindows(pid, graceMs) {
+    // Step 1: Try graceful termination (taskkill without /F)
+    runTaskkill(["/T", "/PID", String(pid)]);
+    // Step 2: Wait grace period, then force kill only if pid still exists.
+    // This avoids unconditional delayed /F kills after graceful shutdown.
+    setTimeout(() => {
+        if (!isProcessAlive(pid)) {
+            return;
+        }
+        runTaskkill(["/F", "/T", "/PID", String(pid)]);
+    }, graceMs).unref(); // Don't block event loop exit
+}