@poolzin/pool-bot 2026.2.17 → 2026.2.19

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/supervisor/adapters/child.js

@@ -0,0 +1,143 @@
+import { killProcessTree } from "../../kill-tree.js";
+import { spawnWithFallback } from "../../spawn-utils.js";
+import { toStringEnv } from "./env.js";
+function resolveCommand(command) {
+    if (process.platform !== "win32") {
+        return command;
+    }
+    const lower = command.toLowerCase();
+    if (lower.endsWith(".exe") || lower.endsWith(".cmd") || lower.endsWith(".bat")) {
+        return command;
+    }
+    const basename = lower.split(/[\\/]/).pop() ?? lower;
+    if (basename === "npm" || basename === "pnpm" || basename === "yarn" || basename === "npx") {
+        return `${command}.cmd`;
+    }
+    return command;
+}
+export async function createChildAdapter(params) {
+    const resolvedArgv = [...params.argv];
+    resolvedArgv[0] = resolveCommand(resolvedArgv[0] ?? "");
+    const stdinMode = params.stdinMode ?? (params.input !== undefined ? "pipe-closed" : "inherit");
+    // On Windows, `detached: true` creates a new process group and can prevent
+    // stdout/stderr pipes from connecting when running under a Scheduled Task
+    // (headless, no console). Default to `detached: false` on Windows; on
+    // POSIX systems keep `detached: true` so the child survives parent exit.
+    const useDetached = process.platform !== "win32";
+    const options = {
+        cwd: params.cwd,
+        env: params.env ? toStringEnv(params.env) : undefined,
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: useDetached,
+        windowsHide: true,
+        windowsVerbatimArguments: params.windowsVerbatimArguments,
+    };
+    if (stdinMode === "inherit") {
+        options.stdio = ["inherit", "pipe", "pipe"];
+    }
+    else {
+        options.stdio = ["pipe", "pipe", "pipe"];
+    }
+    const spawned = await spawnWithFallback({
+        argv: resolvedArgv,
+        options,
+        fallbacks: useDetached
+            ? [
+                {
+                    label: "no-detach",
+                    options: { detached: false },
+                },
+            ]
+            : [],
+    });
+    const child = spawned.child;
+    if (child.stdin) {
+        if (params.input !== undefined) {
+            child.stdin.write(params.input);
+            child.stdin.end();
+        }
+        else if (stdinMode === "pipe-closed") {
+            child.stdin.end();
+        }
+    }
+    const stdin = child.stdin
+        ? {
+            destroyed: false,
+            write: (data, cb) => {
+                try {
+                    child.stdin.write(data, cb);
+                }
+                catch (err) {
+                    cb?.(err);
+                }
+            },
+            end: () => {
+                try {
+                    child.stdin.end();
+                }
+                catch {
+                    // ignore close errors
+                }
+            },
+            destroy: () => {
+                try {
+                    child.stdin.destroy();
+                }
+                catch {
+                    // ignore destroy errors
+                }
+            },
+        }
+        : undefined;
+    const onStdout = (listener) => {
+        child.stdout.on("data", (chunk) => {
+            listener(chunk.toString());
+        });
+    };
+    const onStderr = (listener) => {
+        child.stderr.on("data", (chunk) => {
+            listener(chunk.toString());
+        });
+    };
+    const wait = async () => await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", (code, signal) => {
+            resolve({ code, signal });
+        });
+    });
+    const kill = (signal) => {
+        const pid = child.pid ?? undefined;
+        if (signal === undefined || signal === "SIGKILL") {
+            if (pid) {
+                killProcessTree(pid);
+            }
+            else {
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    // ignore kill errors
+                }
+            }
+            return;
+        }
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // ignore kill errors for non-kill signals
+        }
+    };
+    const dispose = () => {
+        child.removeAllListeners();
+    };
+    return {
+        pid: child.pid ?? undefined,
+        stdin,
+        onStdout,
+        onStderr,
+        wait,
+        kill,
+        dispose,
+    };
+}

package/dist/process/supervisor/adapters/env.js

@@ -0,0 +1,13 @@
+export function toStringEnv(env) {
+    if (!env) {
+        return {};
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (value === undefined) {
+            continue;
+        }
+        out[key] = String(value);
+    }
+    return out;
+}