@pinet/slack-bridge 0.1.0

package/dist/slack-tool-policy-runtime.js

@@ -0,0 +1,96 @@
+import { evaluateSlackOriginCoreToolPolicy } from "./core-tool-guardrails.js";
+import { evaluateSlackOriginRepoToolPolicy } from "./repo-tool-guardrails.js";
+import { isBrokerForbiddenTool } from "./guardrails.js";
+import { consumePendingSlackToolPolicyTurn, deliverTrackedSlackFollowUpMessage as trackAndDeliverSlackFollowUpMessage, } from "./slack-turn-guardrails.js";
+export function createSlackToolPolicyRuntime(deps) {
+    const pendingSlackToolPolicyTurns = [];
+    let nextSlackToolPolicyTurn = null;
+    let activeSlackToolPolicyTurn = null;
+    function deliverTrackedSlackFollowUpMessage(options) {
+        return trackAndDeliverSlackFollowUpMessage({
+            queue: pendingSlackToolPolicyTurns,
+            prompt: options.prompt,
+            messages: options.messages,
+            deliver: deps.deliverFollowUpMessage,
+        });
+    }
+    async function onInput(event) {
+        if (event.source !== "extension") {
+            return;
+        }
+        nextSlackToolPolicyTurn = consumePendingSlackToolPolicyTurn(pendingSlackToolPolicyTurns, event.text);
+    }
+    async function onTurnStart() {
+        activeSlackToolPolicyTurn = nextSlackToolPolicyTurn;
+        nextSlackToolPolicyTurn = null;
+        if (activeSlackToolPolicyTurn?.channel && activeSlackToolPolicyTurn.threadTs) {
+            await deps
+                .beginThreadStatus?.(activeSlackToolPolicyTurn.channel, activeSlackToolPolicyTurn.threadTs, "is thinking…")
+                .catch(() => {
+                /* best effort */
+            });
+        }
+    }
+    async function onTurnEnd() {
+        const turn = activeSlackToolPolicyTurn;
+        activeSlackToolPolicyTurn = null;
+        if (turn?.channel && turn.threadTs) {
+            await deps.clearThreadStatus?.(turn.channel, turn.threadTs).catch(() => {
+                /* best effort */
+            });
+        }
+    }
+    async function onAgentEnd() {
+        const turn = activeSlackToolPolicyTurn;
+        activeSlackToolPolicyTurn = null;
+        if (turn?.channel && turn.threadTs) {
+            await deps.clearThreadStatus?.(turn.channel, turn.threadTs).catch(() => {
+                /* best effort */
+            });
+        }
+    }
+    async function onToolCall(event) {
+        if (activeSlackToolPolicyTurn?.channel && activeSlackToolPolicyTurn.threadTs) {
+            await deps
+                .updateThreadStatus?.(activeSlackToolPolicyTurn.channel, activeSlackToolPolicyTurn.threadTs, "Calling tool…")
+                .catch(() => {
+                /* best effort */
+            });
+        }
+        if (deps.getBrokerRole() === "broker" && isBrokerForbiddenTool(event.toolName)) {
+            return {
+                block: true,
+                reason: `Tool "${event.toolName}" is forbidden for the broker role. The broker coordinates — it does not code. Use pinet action=send to delegate to a connected worker instead.`,
+            };
+        }
+        const corePolicy = evaluateSlackOriginCoreToolPolicy({
+            turn: activeSlackToolPolicyTurn,
+            toolName: event.toolName,
+            input: event.input,
+            guardrails: deps.getGuardrails(),
+            requireToolPolicy: deps.requireToolPolicy,
+            formatAction: deps.formatAction,
+            formatError: deps.formatError,
+        });
+        if (corePolicy) {
+            return corePolicy;
+        }
+        return evaluateSlackOriginRepoToolPolicy({
+            turn: activeSlackToolPolicyTurn,
+            toolName: event.toolName,
+            input: event.input,
+            guardrails: deps.getGuardrails(),
+            requireToolPolicy: deps.requireToolPolicy,
+            formatAction: deps.formatAction,
+            formatError: deps.formatError,
+        });
+    }
+    return {
+        deliverTrackedSlackFollowUpMessage,
+        onInput,
+        onTurnStart,
+        onTurnEnd,
+        onAgentEnd,
+        onToolCall,
+    };
+}

package/dist/slack-tools.d.ts

@@ -0,0 +1,52 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { InboxMessage } from "./helpers.js";
+import type { SlackResult } from "./slack-api.js";
+export interface SlackToolsThreadContextPort {
+    resolveThreadChannel: (threadTs: string | undefined) => Promise<string | null>;
+    noteThreadReply: (threadTs: string, channelId: string) => void;
+    clearPendingAttention: (threadTs: string) => void;
+}
+export interface SlackPinetDeliveryInput {
+    threadId: string;
+    channel: string;
+    text: string;
+    blocks?: ReadonlyArray<Record<string, unknown>>;
+}
+export interface SlackPinetDeliveryResult {
+    adapter: string;
+    messageId: number;
+    threadId: string;
+    channel: string;
+    source: string;
+}
+export interface SlackPinetDeliveryPort {
+    isAvailable: () => boolean;
+    sendSlackMessage: (input: SlackPinetDeliveryInput) => Promise<SlackPinetDeliveryResult>;
+}
+export interface RegisterSlackToolsDeps {
+    getBotToken: () => string;
+    getDefaultChannel: () => string | undefined;
+    getSecurityPrompt: () => string;
+    inbox: InboxMessage[];
+    slack: (method: string, token: string, body?: Record<string, unknown>) => Promise<SlackResult>;
+    getAgentName: () => string;
+    getAgentEmoji: () => string;
+    getAgentOwnerToken: () => string;
+    getLastDmChannel: () => string | null;
+    updateBadge: () => void;
+    resolveUser: (userId: string) => Promise<string>;
+    threadContext: SlackToolsThreadContextPort;
+    resolveChannel: (nameOrId: string) => Promise<string>;
+    rememberChannel: (name: string, channelId: string) => void;
+    requireToolPolicy: (toolName: string, threadTs: string | undefined, action: string) => void;
+    registerConfirmationRequest: (threadTs: string, tool: string, action: string) => {
+        status: "created" | "refreshed" | "conflict";
+        conflict?: {
+            toolPattern: string;
+            action: string;
+        };
+    };
+    getBotUserId: () => string | null;
+    pinetDelivery?: SlackPinetDeliveryPort;
+}
+export declare function registerSlackTools(pi: ExtensionAPI, deps: RegisterSlackToolsDeps): void;