@poolzin/pool-bot 2026.3.6 → 2026.3.7

package/dist/security/middleware.js

@@ -0,0 +1,105 @@
+import { getCapabilityManager } from "./capability-manager.js";
+import { CapabilityError } from "./capability-guards.js";
+import { logVerbose } from "../globals.js";
+/**
+ * Creates a middleware that checks tool invocation capabilities.
+ */
+export function createCapabilityMiddleware() {
+    return async (ctx, toolId, _args, next) => {
+        const manager = getCapabilityManager();
+        // Check for tool:all first (grants any tool)
+        const allCheck = manager.check(ctx.agentId, { type: "tool:all" });
+        if (allCheck.granted) {
+            logVerbose(`[capability] ${ctx.agentId} granted tool:all for ${toolId}`);
+            return await next();
+        }
+        // Check for specific tool invocation
+        const toolCheck = manager.check(ctx.agentId, {
+            type: "tool:invoke",
+            toolId,
+        });
+        if (!toolCheck.granted) {
+            logVerbose(`[capability] ${ctx.agentId} denied access to tool ${toolId}: ${toolCheck.reason}`);
+            throw new CapabilityError(`Tool '${toolId}' access denied: ${toolCheck.reason}`, ctx.agentId, { type: "tool:invoke", toolId });
+        }
+        logVerbose(`[capability] ${ctx.agentId} granted access to ${toolId}`);
+        return await next();
+    };
+}
+/**
+ * Creates a middleware that checks file access capabilities.
+ */
+export function createFileAccessMiddleware() {
+    return async (ctx, toolId, args, next) => {
+        // Tools that read files
+        if (toolId === "file_read" || toolId === "read_file") {
+            const path = args.path || args.file_path || args.filePath;
+            if (typeof path === "string") {
+                const manager = getCapabilityManager();
+                const check = manager.check(ctx.agentId, {
+                    type: "file:read",
+                    pattern: path,
+                });
+                if (!check.granted) {
+                    throw new CapabilityError(`File read denied for '${path}': ${check.reason}`, ctx.agentId, { type: "file:read", pattern: path });
+                }
+            }
+        }
+        // Tools that write files
+        if (toolId === "file_write" || toolId === "write_file") {
+            const path = args.path || args.file_path || args.filePath;
+            if (typeof path === "string") {
+                const manager = getCapabilityManager();
+                const check = manager.check(ctx.agentId, {
+                    type: "file:write",
+                    pattern: path,
+                });
+                if (!check.granted) {
+                    throw new CapabilityError(`File write denied for '${path}': ${check.reason}`, ctx.agentId, { type: "file:write", pattern: path });
+                }
+            }
+        }
+        return await next();
+    };
+}
+/**
+ * Creates a middleware that checks shell execution capabilities.
+ */
+export function createShellExecutionMiddleware() {
+    return async (ctx, toolId, args, next) => {
+        if (toolId === "shell" || toolId === "bash" || toolId === "exec") {
+            const command = args.command || args.cmd || args.shell;
+            if (typeof command === "string") {
+                const manager = getCapabilityManager();
+                const check = manager.check(ctx.agentId, {
+                    type: "shell:exec",
+                    pattern: command,
+                });
+                if (!check.granted) {
+                    throw new CapabilityError(`Shell execution denied for '${command}': ${check.reason}`, ctx.agentId, { type: "shell:exec", pattern: command });
+                }
+            }
+        }
+        return await next();
+    };
+}
+/**
+ * Composes multiple middlewares into a single middleware.
+ */
+export function composeMiddlewares(...middlewares) {
+    return async (ctx, toolId, args, finalNext) => {
+        let index = 0;
+        const dispatch = async () => {
+            if (index >= middlewares.length) {
+                return await finalNext();
+            }
+            const middleware = middlewares[index++];
+            return await middleware(ctx, toolId, args, dispatch);
+        };
+        return await dispatch();
+    };
+}
+/** Default security middleware stack. */
+export function createDefaultSecurityMiddleware() {
+    return composeMiddlewares(createCapabilityMiddleware(), createFileAccessMiddleware(), createShellExecutionMiddleware());
+}

package/dist/slack/monitor/context.js

@@ -228,6 +228,7 @@ export function createSlackMonitorContext(params) {
         slashCommand: params.slashCommand,
         textLimit: params.textLimit,
         ackReactionScope: params.ackReactionScope,
+        typingReaction: params.typingReaction,
         mediaMaxBytes: params.mediaMaxBytes,
         removeAckAfterReply: params.removeAckAfterReply,
         logger,

package/dist/slack/monitor/message-handler/dispatch.js

@@ -8,7 +8,7 @@ import { createReplyPrefixOptions } from "../../../channels/reply-prefix.js";
 import { createTypingCallbacks } from "../../../channels/typing.js";
 import { resolveStorePath, updateLastRoute } from "../../../config/sessions.js";
 import { danger, logVerbose, shouldLogVerbose } from "../../../globals.js";
-import { removeSlackReaction } from "../../actions.js";
+import { reactSlackMessage, removeSlackReaction } from "../../actions.js";
 import { createSlackDraftStream } from "../../draft-stream.js";
 import { applyAppendOnlyStreamUpdate, buildStatusFinalPreviewText, resolveSlackStreamingConfig, } from "../../stream-mode.js";
 import { appendSlackStream, startSlackStream, stopSlackStream } from "../../streaming.js";
@@ -78,6 +78,7 @@ export async function dispatchPreparedSlackMessage(prepared) {
         hasRepliedRef,
     });
     const typingTarget = statusThreadTs ? `${message.channel}/${statusThreadTs}` : message.channel;
+    const typingReaction = ctx.typingReaction;
     const typingCallbacks = createTypingCallbacks({
         start: async () => {
             didSetStatus = true;
@@ -86,6 +87,12 @@ export async function dispatchPreparedSlackMessage(prepared) {
                 threadTs: statusThreadTs,
                 status: "is typing...",
             });
+            if (typingReaction && message.ts) {
+                await reactSlackMessage(message.channel, message.ts, typingReaction, {
+                    token: ctx.botToken,
+                    client: ctx.app.client,
+                }).catch(() => { });
+            }
         },
         stop: async () => {
             if (!didSetStatus) {
@@ -97,6 +104,12 @@ export async function dispatchPreparedSlackMessage(prepared) {
                 threadTs: statusThreadTs,
                 status: "",
             });
+            if (typingReaction && message.ts) {
+                await removeSlackReaction(message.channel, message.ts, typingReaction, {
+                    token: ctx.botToken,
+                    client: ctx.app.client,
+                }).catch(() => { });
+            }
         },
         onStartError: (err) => {
             logTypingFailure({

package/dist/slack/monitor/provider.js

@@ -90,6 +90,7 @@ export async function monitorSlackProvider(opts = {}) {
     const ackReactionScope = cfg.messages?.ackReactionScope ?? "group-mentions";
     const mediaMaxBytes = (opts.mediaMaxMb ?? slackCfg.mediaMaxMb ?? 20) * 1024 * 1024;
     const removeAckAfterReply = cfg.messages?.removeAckAfterReply ?? false;
+    const typingReaction = slackCfg.typingReaction ?? "";
     const receiver = slackMode === "http"
         ? new HTTPReceiver({
             signingSecret: signingSecret ?? "",
@@ -160,6 +161,7 @@ export async function monitorSlackProvider(opts = {}) {
         slashCommand,
         textLimit,
         ackReactionScope,
+        typingReaction,
         mediaMaxBytes,
         removeAckAfterReply,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/pool-bot",
-  "version": "2026.3.6",
+  "version": "2026.3.7",
   "description": "🎱 Pool Bot - AI assistant with PLCODE integrations",
   "keywords": [],
   "license": "MIT",