@pinet/slack-bridge 0.1.0

package/dist/activity-log.js

@@ -0,0 +1,293 @@
+const LEVEL_RANK = {
+    errors: 0,
+    actions: 1,
+    verbose: 2,
+};
+const DEFAULT_MAX_RECENT_ENTRIES = 100;
+const MAX_TEXT_LENGTH = 2800;
+const REDACTED = "[REDACTED]";
+function normalizeWhitespace(value) {
+    return value.replace(/\r\n/g, "\n").replaceAll("\u0000", "").trim();
+}
+function truncate(value, maxLength = MAX_TEXT_LENGTH) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+export function normalizeActivityLogLevel(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "errors" || normalized === "actions" || normalized === "verbose") {
+        return normalized;
+    }
+    return "actions";
+}
+export function shouldLogActivity(configuredLevel, eventLevel) {
+    return LEVEL_RANK[eventLevel] <= LEVEL_RANK[configuredLevel];
+}
+export function redactSensitiveText(value) {
+    let redacted = normalizeWhitespace(value);
+    const replacements = [
+        [/xox[baprs]-[A-Za-z0-9-]+/g, REDACTED],
+        [/xoxe\.[A-Za-z0-9.-]+/g, REDACTED],
+        [/(Bearer\s+)[^\s]+/gi, `$1${REDACTED}`],
+        [
+            /\b(token|password|secret|api[_-]?key|authorization)\b\s*([:=])\s*([^\s,;]+)/gi,
+            `$1$2 ${REDACTED}`,
+        ],
+        [
+            /("(?:token|password|secret|api[_-]?key|authorization)"\s*:\s*")([^"]+)(")/gi,
+            `$1${REDACTED}$3`,
+        ],
+        [/(SLACK_[A-Z_]+)=([^\s]+)/g, `$1=${REDACTED}`],
+    ];
+    for (const [pattern, replacement] of replacements) {
+        redacted = redacted.replace(pattern, replacement);
+    }
+    return truncate(redacted);
+}
+function sanitizeFieldValue(value) {
+    if (value == null) {
+        return "—";
+    }
+    if (typeof value === "boolean") {
+        return value ? "yes" : "no";
+    }
+    return redactSensitiveText(String(value));
+}
+function sanitizeEntry(entry, now) {
+    return {
+        ...entry,
+        title: redactSensitiveText(entry.title),
+        summary: redactSensitiveText(entry.summary),
+        details: entry.details?.map((detail) => redactSensitiveText(detail)).filter(Boolean),
+        fields: entry.fields
+            ?.map((field) => ({
+            label: redactSensitiveText(field.label),
+            value: sanitizeFieldValue(field.value),
+        }))
+            .filter((field) => field.label.length > 0),
+        timestamp: entry.timestamp ?? now.toISOString(),
+    };
+}
+function getToneEmoji(tone) {
+    switch (tone) {
+        case "success":
+            return "✅";
+        case "warning":
+            return "⚠️";
+        case "error":
+            return "🚨";
+        case "info":
+        default:
+            return "📡";
+    }
+}
+function formatSlackTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime())) {
+        return timestamp;
+    }
+    return date.toISOString().replace(".000Z", "Z");
+}
+export function buildActivityLogText(agentName, agentEmoji, entry) {
+    return `${getToneEmoji(entry.tone)} ${entry.title} — ${entry.summary} (${agentEmoji} ${agentName} · ${formatSlackTimestamp(entry.timestamp)})`;
+}
+export function buildActivityLogBlocks(agentName, agentEmoji, entry) {
+    const blocks = [
+        {
+            type: "section",
+            text: {
+                type: "mrkdwn",
+                text: `*${getToneEmoji(entry.tone)} ${entry.title}*\n${entry.summary}`,
+            },
+        },
+    ];
+    const fields = (entry.fields ?? [])
+        .filter((field) => field.value !== "—")
+        .slice(0, 10)
+        .map((field) => ({
+        type: "mrkdwn",
+        text: `*${field.label}*\n${field.value}`,
+    }));
+    if (fields.length > 0) {
+        blocks.push({ type: "section", fields });
+    }
+    if (entry.details && entry.details.length > 0) {
+        blocks.push({
+            type: "section",
+            text: {
+                type: "mrkdwn",
+                text: entry.details.map((detail) => `• ${detail}`).join("\n"),
+            },
+        });
+    }
+    blocks.push({
+        type: "context",
+        elements: [
+            {
+                type: "mrkdwn",
+                text: `${agentEmoji} ${agentName} · ${entry.kind} · ${formatSlackTimestamp(entry.timestamp)}`,
+            },
+        ],
+    });
+    return blocks;
+}
+export function buildActivityLogThreadHeader(agentName, agentEmoji, dateKey) {
+    return {
+        text: `Pinet activity log — ${dateKey}`,
+        blocks: [
+            {
+                type: "section",
+                text: {
+                    type: "mrkdwn",
+                    text: `*📚 Pinet activity log — ${dateKey}*\nBroker-side coordination updates: assignments, completions, merges, stalls, and RALPH maintenance events.`,
+                },
+            },
+            {
+                type: "context",
+                elements: [
+                    {
+                        type: "mrkdwn",
+                        text: `${agentEmoji} ${agentName} · daily thread`,
+                    },
+                ],
+            },
+        ],
+    };
+}
+export function formatRecentActivityLogEntries(entries) {
+    if (entries.length === 0) {
+        return "No activity log entries recorded in this session.";
+    }
+    return entries
+        .map((entry) => `[${formatSlackTimestamp(entry.timestamp)}] ${entry.title} — ${entry.summary}`)
+        .join("\n");
+}
+export class SlackActivityLogger {
+    deps;
+    queue = [];
+    recent = [];
+    maxRecentEntries;
+    flushTimer = null;
+    flushRunning = false;
+    resolvedChannelCache = null;
+    dailyThreadCache = null;
+    constructor(deps) {
+        this.deps = deps;
+        this.maxRecentEntries = deps.maxRecentEntries ?? DEFAULT_MAX_RECENT_ENTRIES;
+    }
+    log(entry) {
+        const rawChannel = this.deps.getLogChannel()?.trim();
+        if (!rawChannel) {
+            return;
+        }
+        const configuredLevel = normalizeActivityLogLevel(this.deps.getLogLevel());
+        if (!shouldLogActivity(configuredLevel, entry.level)) {
+            return;
+        }
+        const sanitized = sanitizeEntry(entry, this.getNow());
+        this.recent.unshift(sanitized);
+        this.recent.splice(this.maxRecentEntries);
+        this.queue.push({ entry: sanitized, attempts: 0 });
+        this.scheduleFlush(0);
+    }
+    getRecentEntries(limit = 20) {
+        return this.recent.slice(0, Math.max(0, limit));
+    }
+    clearPending() {
+        this.queue.splice(0, this.queue.length);
+        this.resolvedChannelCache = null;
+        this.dailyThreadCache = null;
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+    getNow() {
+        return this.deps.now ? this.deps.now() : new Date();
+    }
+    scheduleFlush(delayMs) {
+        if (this.flushTimer || this.flushRunning || this.queue.length === 0) {
+            return;
+        }
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flushNext();
+        }, delayMs);
+        this.flushTimer.unref?.();
+    }
+    async flushNext() {
+        if (this.flushRunning) {
+            return;
+        }
+        const next = this.queue.shift();
+        if (!next) {
+            return;
+        }
+        this.flushRunning = true;
+        try {
+            await this.postEntry(next.entry);
+        }
+        catch (error) {
+            if (next.attempts < 2) {
+                this.queue.unshift({ entry: next.entry, attempts: next.attempts + 1 });
+            }
+            else {
+                this.deps.onError?.(error);
+            }
+        }
+        finally {
+            this.flushRunning = false;
+            if (this.queue.length > 0) {
+                this.scheduleFlush(1000);
+            }
+        }
+    }
+    async resolveLogChannel(rawChannel) {
+        if (this.resolvedChannelCache?.raw === rawChannel) {
+            return this.resolvedChannelCache.id;
+        }
+        const channelId = await this.deps.resolveChannel(rawChannel);
+        this.resolvedChannelCache = { raw: rawChannel, id: channelId };
+        return channelId;
+    }
+    async ensureDailyThread(rawChannel, channelId) {
+        const dateKey = this.getNow().toISOString().slice(0, 10);
+        if (this.dailyThreadCache?.rawChannel === rawChannel &&
+            this.dailyThreadCache.dateKey === dateKey) {
+            return this.dailyThreadCache.threadTs;
+        }
+        const token = this.deps.getBotToken();
+        if (!token) {
+            throw new Error("Slack bot token unavailable for activity logging.");
+        }
+        const heading = buildActivityLogThreadHeader(this.deps.getAgentName(), this.deps.getAgentEmoji(), dateKey);
+        const response = await this.deps.slack("chat.postMessage", token, {
+            channel: channelId,
+            text: heading.text,
+            blocks: heading.blocks,
+        });
+        const threadTs = typeof response.ts === "string" ? response.ts : null;
+        if (!threadTs) {
+            throw new Error("Slack activity log thread creation did not return a ts.");
+        }
+        this.dailyThreadCache = { rawChannel, dateKey, threadTs };
+        return threadTs;
+    }
+    async postEntry(entry) {
+        const rawChannel = this.deps.getLogChannel()?.trim();
+        const token = this.deps.getBotToken();
+        if (!rawChannel || !token) {
+            return;
+        }
+        const channelId = await this.resolveLogChannel(rawChannel);
+        const threadTs = await this.ensureDailyThread(rawChannel, channelId);
+        await this.deps.slack("chat.postMessage", token, {
+            channel: channelId,
+            thread_ts: threadTs,
+            text: buildActivityLogText(this.deps.getAgentName(), this.deps.getAgentEmoji(), entry),
+            blocks: buildActivityLogBlocks(this.deps.getAgentName(), this.deps.getAgentEmoji(), entry),
+        });
+    }
+}

package/dist/agent-completion-runtime.d.ts

@@ -0,0 +1,17 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+interface AgentCompletionThreadState {
+    channelId: string;
+}
+export interface AgentCompletionRuntimeDeps {
+    getThreads: () => Map<string, AgentCompletionThreadState>;
+    clearThreadStatus: (channelId: string, threadTs: string) => Promise<void>;
+    clearFollowUpPending: () => void;
+    signalAgentFree: (ctx: ExtensionContext) => Promise<unknown>;
+    formatError: (error: unknown) => string;
+}
+export interface AgentCompletionRuntime {
+    trackThinkingThread: (threadTs: string) => void;
+    onAgentEnd: (_event: unknown, ctx: ExtensionContext) => Promise<void>;
+}
+export declare function createAgentCompletionRuntime(deps: AgentCompletionRuntimeDeps): AgentCompletionRuntime;
+export {};

package/dist/agent-completion-runtime.js

@@ -0,0 +1,26 @@
+export function createAgentCompletionRuntime(deps) {
+    const thinking = new Set();
+    function trackThinkingThread(threadTs) {
+        thinking.add(threadTs);
+    }
+    async function onAgentEnd(_event, ctx) {
+        for (const threadTs of thinking) {
+            const thread = deps.getThreads().get(threadTs);
+            if (thread) {
+                await deps.clearThreadStatus(thread.channelId, threadTs);
+            }
+        }
+        thinking.clear();
+        deps.clearFollowUpPending();
+        try {
+            await deps.signalAgentFree(ctx);
+        }
+        catch (err) {
+            ctx.ui.notify(`Pinet auto-free failed: ${deps.formatError(err)}`, "warning");
+        }
+    }
+    return {
+        trackThinkingThread,
+        onAgentEnd,
+    };
+}

package/dist/agent-event-runtime.d.ts

@@ -0,0 +1,13 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AgentCompletionRuntime } from "./agent-completion-runtime.js";
+import type { AgentPromptGuidance } from "./agent-prompt-guidance.js";
+import { type SlackToolPolicyRuntime, type SlackToolPolicyRuntimeDeps } from "./slack-tool-policy-runtime.js";
+export interface AgentEventRuntimeDeps extends SlackToolPolicyRuntimeDeps {
+    beforeAgentStart: AgentPromptGuidance["beforeAgentStart"];
+    onCompletionAgentEnd: AgentCompletionRuntime["onAgentEnd"];
+    setDeliverTrackedSlackFollowUpMessage: (deliver: SlackToolPolicyRuntime["deliverTrackedSlackFollowUpMessage"]) => void;
+}
+export interface AgentEventRuntime {
+    register: (pi: Pick<ExtensionAPI, "on">) => void;
+}
+export declare function createAgentEventRuntime(deps: AgentEventRuntimeDeps): AgentEventRuntime;

package/dist/agent-event-runtime.js

@@ -0,0 +1,27 @@
+import { createSlackToolPolicyRuntime, } from "./slack-tool-policy-runtime.js";
+export function createAgentEventRuntime(deps) {
+    const slackToolPolicyRuntime = createSlackToolPolicyRuntime({
+        getBrokerRole: deps.getBrokerRole,
+        getGuardrails: deps.getGuardrails,
+        requireToolPolicy: deps.requireToolPolicy,
+        formatAction: deps.formatAction,
+        formatError: deps.formatError,
+        deliverFollowUpMessage: deps.deliverFollowUpMessage,
+        beginThreadStatus: deps.beginThreadStatus,
+        updateThreadStatus: deps.updateThreadStatus,
+        clearThreadStatus: deps.clearThreadStatus,
+    });
+    deps.setDeliverTrackedSlackFollowUpMessage(slackToolPolicyRuntime.deliverTrackedSlackFollowUpMessage);
+    function register(pi) {
+        pi.on("input", slackToolPolicyRuntime.onInput);
+        pi.on("turn_start", slackToolPolicyRuntime.onTurnStart);
+        pi.on("turn_end", slackToolPolicyRuntime.onTurnEnd);
+        pi.on("agent_end", slackToolPolicyRuntime.onAgentEnd);
+        pi.on("tool_call", slackToolPolicyRuntime.onToolCall);
+        pi.on("before_agent_start", deps.beforeAgentStart);
+        pi.on("agent_end", deps.onCompletionAgentEnd);
+    }
+    return {
+        register,
+    };
+}

package/dist/agent-prompt-guidance.d.ts

@@ -0,0 +1,22 @@
+import { type BrokerPromptLoadResult } from "./broker-prompt-loader.js";
+export interface BeforeAgentStartEvent {
+    systemPrompt: string;
+}
+export interface AgentPromptGuidanceDeps {
+    getIdentityGuidelines: () => string[];
+    getAgentName: () => string;
+    getAgentEmoji: () => string;
+    getActiveSkinTheme: () => string | null;
+    getAgentPersonality: () => string | null;
+    getBrokerRole: () => "broker" | "follower" | null;
+    getBrokerPromptSetting?: () => string | undefined;
+    loadBrokerPrompt?: () => Promise<BrokerPromptLoadResult>;
+    reportBrokerPromptWarning?: (warning: string) => void;
+    reportBrokerPromptDiagnostic?: (diagnostic: string) => void;
+}
+export interface AgentPromptGuidance {
+    beforeAgentStart: (event: BeforeAgentStartEvent) => Promise<{
+        systemPrompt: string;
+    }>;
+}
+export declare function createAgentPromptGuidance(deps: AgentPromptGuidanceDeps): AgentPromptGuidance;

package/dist/agent-prompt-guidance.js

@@ -0,0 +1,46 @@
+import { buildAgentPersonalityGuidelines, buildBrokerProtocolGuardrailsPrompt, buildPinetSkinPromptGuideline, buildWorkerPromptGuidelines, } from "./helpers.js";
+import { buildBrokerToolGuardrailsPrompt } from "./guardrails.js";
+import { loadBrokerPrompt, renderBrokerPromptContent, } from "./broker-prompt-loader.js";
+import { buildReactionPromptGuidelines } from "./reaction-triggers.js";
+export function createAgentPromptGuidance(deps) {
+    async function buildPromptGuidelines() {
+        const agentName = deps.getAgentName();
+        const guidelines = [
+            ...deps.getIdentityGuidelines(),
+            ...buildAgentPersonalityGuidelines(agentName),
+            ...buildReactionPromptGuidelines(),
+        ];
+        const skinGuideline = buildPinetSkinPromptGuideline(deps.getActiveSkinTheme(), deps.getAgentPersonality());
+        if (skinGuideline) {
+            guidelines.push(skinGuideline);
+        }
+        if (deps.getBrokerRole() === "broker") {
+            const brokerPrompt = await (deps.loadBrokerPrompt ??
+                (() => loadBrokerPrompt({
+                    configuredPrompt: deps.getBrokerPromptSetting?.(),
+                })))();
+            for (const warning of brokerPrompt.warnings) {
+                (deps.reportBrokerPromptWarning ?? console.warn)(`[slack-bridge] ${warning.message}`);
+            }
+            (deps.reportBrokerPromptDiagnostic ?? console.info)(`[slack-bridge] ${brokerPrompt.diagnostic}`);
+            guidelines.push(renderBrokerPromptContent(brokerPrompt.content, {
+                agentEmoji: deps.getAgentEmoji(),
+                agentName,
+            }));
+            guidelines.push(buildBrokerProtocolGuardrailsPrompt());
+            guidelines.push(buildBrokerToolGuardrailsPrompt());
+        }
+        else if (deps.getBrokerRole() === "follower") {
+            guidelines.push(...buildWorkerPromptGuidelines());
+        }
+        return guidelines;
+    }
+    async function beforeAgentStart(event) {
+        return {
+            systemPrompt: event.systemPrompt + "\n\n" + (await buildPromptGuidelines()).join("\n"),
+        };
+    }
+    return {
+        beforeAgentStart,
+    };
+}

package/dist/broker/adapters/slack.d.ts

@@ -0,0 +1,74 @@
+import { type ParsedAppHomeOpened, type ParsedThreadStarted } from "../../slack-access.js";
+import { type ReactionCommandSettings } from "../../reaction-triggers.js";
+import type { AdapterCapabilityRequest, AdapterCapabilityResult, InboundMessage, OutboundMessage, MessageAdapter } from "./types.js";
+export { classifyMessage, extractAppHomeOpened, extractThreadStarted, parseMemberJoinedChannel, parseSocketFrame, RECONNECT_DELAY_MS, } from "../../slack-access.js";
+export interface SlackAdapterConfig {
+    botToken: string;
+    appToken: string;
+    allowedUsers?: string[];
+    allowAllWorkspaceUsers?: boolean;
+    suggestedPrompts?: {
+        title: string;
+        message: string;
+    }[];
+    reactionCommands?: ReactionCommandSettings;
+    /** Check whether a thread_ts belongs to a known thread in the broker DB. */
+    isKnownThread?: (threadTs: string) => boolean;
+    /** Load durable thread metadata from the broker DB after cache eviction. */
+    getKnownThread?: (threadTs: string) => {
+        channelId: string;
+        context?: ParsedThreadStarted["context"] | null;
+    } | null;
+    /** Persist thread metadata in the broker DB without claiming ownership. */
+    rememberKnownThread?: (threadTs: string, channelId: string, context?: ParsedThreadStarted["context"] | null) => void;
+    /** Best-effort callback for Home tab opens. */
+    onAppHomeOpened?: (event: ParsedAppHomeOpened) => Promise<void> | void;
+}
+export declare const SLACK_THREAD_CACHE_MAX_SIZE = 5000;
+export declare const SLACK_THREAD_CACHE_TTL_MS: number;
+export declare const SLACK_PENDING_ATTENTION_MAX_THREADS = 1000;
+export declare const SLACK_PENDING_ATTENTION_TTL_MS: number;
+export declare const SLACK_PENDING_ATTENTION_MAX_MESSAGES_PER_THREAD = 50;
+export declare class SlackAdapter implements MessageAdapter {
+    readonly name = "slack";
+    private readonly config;
+    private readonly allowlist;
+    private slackRequests;
+    private botUserId;
+    private socketMode;
+    private shuttingDown;
+    private inboundHandler;
+    private readonly reactionCommands;
+    private readonly threads;
+    private readonly userNames;
+    private readonly processedSocketDeliveries;
+    private readonly pendingEyes;
+    private readonly threadStatuses;
+    constructor(config: SlackAdapterConfig);
+    private callSlack;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    onInbound(handler: (msg: InboundMessage) => void): void;
+    invokeCapability(request: AdapterCapabilityRequest): Promise<AdapterCapabilityResult>;
+    send(msg: OutboundMessage): Promise<void>;
+    private buildSlackApiCapabilityEffects;
+    getBotUserId(): string | null;
+    getTrackedThreadIds(): Set<string>;
+    isConnected(): boolean;
+    private resolveScopeForThread;
+    private onThreadStarted;
+    private onContextChanged;
+    private onAppHomeOpened;
+    private fetchMessageByTs;
+    private onReactionAdded;
+    private onMessage;
+    private emitInteractiveInbound;
+    private onMemberJoined;
+    private shouldSuppressLegacyThreadedDm;
+    private getThread;
+    private addReaction;
+    private removeReaction;
+    private resolveUser;
+    private clearThreadStatus;
+    private setSuggestedPrompts;
+}