@pinet/slack-bridge 0.1.0

package/dist/slack-modals.d.ts

@@ -0,0 +1,13 @@
+export type SlackModalView = Record<string, unknown>;
+export declare function normalizeSlackModalViewInput(view: unknown): SlackModalView;
+export interface SlackModalThreadContext {
+    threadTs: string;
+    channel: string;
+}
+export interface DecodedSlackModalPrivateMetadata {
+    raw: string | null;
+    value: unknown;
+    threadContext: SlackModalThreadContext | null;
+}
+export declare function encodeSlackModalPrivateMetadata(privateMetadata: string | undefined, threadContext: SlackModalThreadContext | null): string | undefined;
+export declare function decodeSlackModalPrivateMetadata(privateMetadata: string | undefined): DecodedSlackModalPrivateMetadata;

package/dist/slack-modals.js

@@ -0,0 +1,79 @@
+const PI_SLACK_MODAL_CONTEXT_KEY = "__piSlackModalContext";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function asOptionalString(value) {
+    return typeof value === "string" ? value : null;
+}
+export function normalizeSlackModalViewInput(view) {
+    if (!isRecord(view)) {
+        throw new Error("Slack modal view must be a JSON object.");
+    }
+    const cloned = structuredClone(view);
+    if (cloned.type !== "modal") {
+        throw new Error('Slack modal view.type must be "modal".');
+    }
+    return cloned;
+}
+export function encodeSlackModalPrivateMetadata(privateMetadata, threadContext) {
+    if (!threadContext) {
+        return privateMetadata;
+    }
+    const raw = privateMetadata?.trim();
+    let value = raw ?? null;
+    if (raw) {
+        try {
+            value = JSON.parse(raw);
+        }
+        catch {
+            value = raw;
+        }
+    }
+    if (isRecord(value)) {
+        return JSON.stringify({
+            ...value,
+            [PI_SLACK_MODAL_CONTEXT_KEY]: threadContext,
+        });
+    }
+    return JSON.stringify({
+        [PI_SLACK_MODAL_CONTEXT_KEY]: threadContext,
+        value,
+    });
+}
+export function decodeSlackModalPrivateMetadata(privateMetadata) {
+    const raw = asOptionalString(privateMetadata);
+    if (!raw) {
+        return { raw, value: null, threadContext: null };
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (isRecord(parsed)) {
+            const context = parsed[PI_SLACK_MODAL_CONTEXT_KEY];
+            const threadContext = isRecord(context)
+                ? {
+                    threadTs: asString(context.threadTs) ?? "",
+                    channel: asString(context.channel) ?? "",
+                }
+                : null;
+            const normalizedContext = threadContext && threadContext.threadTs && threadContext.channel ? threadContext : null;
+            if (PI_SLACK_MODAL_CONTEXT_KEY in parsed) {
+                const clone = { ...parsed };
+                delete clone[PI_SLACK_MODAL_CONTEXT_KEY];
+                const userValue = Object.keys(clone).length === 1 && "value" in clone ? clone.value : clone;
+                return {
+                    raw,
+                    value: userValue,
+                    threadContext: normalizedContext,
+                };
+            }
+            return { raw, value: parsed, threadContext: normalizedContext };
+        }
+        return { raw, value: parsed, threadContext: null };
+    }
+    catch {
+        return { raw, value: raw, threadContext: null };
+    }
+}

package/dist/slack-pinet-runtime-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ThreadInfo } from "./broker/index.js";
+import type { PinetRuntimeAdapterFactory } from "./pinet-runtime-composition.js";
+import type { SlackThreadContext } from "./slack-access.js";
+import type { SlackBridgeSettings } from "./helpers.js";
+export declare function readStoredSlackThreadContext(metadata: Record<string, unknown> | null | undefined): SlackThreadContext | null;
+export declare function shouldRouteKnownSlackThread(thread: Pick<ThreadInfo, "source" | "channel" | "metadata"> | null): boolean;
+export interface SlackPinetRuntimeAdapterDeps {
+    getSettings: () => SlackBridgeSettings;
+    getBotToken: () => string;
+    getAppToken: () => string;
+    getAllowedUsers: () => Set<string> | null;
+    shouldAllowAllWorkspaceUsers: () => boolean;
+    onAppHomeOpened: (userId: string, ctx: ExtensionContext) => Promise<void> | void;
+}
+export declare function createSlackPinetRuntimeAdapterFactory(deps: SlackPinetRuntimeAdapterDeps): PinetRuntimeAdapterFactory;

package/dist/slack-pinet-runtime-adapter.js

@@ -0,0 +1,72 @@
+import { SlackAdapter } from "./broker/adapters/slack.js";
+export function readStoredSlackThreadContext(metadata) {
+    const value = metadata?.slackThreadContext;
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    const record = value;
+    if (typeof record.channelId !== "string" || record.channelId.length === 0)
+        return null;
+    if (typeof record.scope !== "object" || record.scope === null || Array.isArray(record.scope)) {
+        return null;
+    }
+    return {
+        channelId: record.channelId,
+        ...(typeof record.teamId === "string" && record.teamId.length > 0
+            ? { teamId: record.teamId }
+            : {}),
+        scope: record.scope,
+    };
+}
+export function shouldRouteKnownSlackThread(thread) {
+    if (!thread || thread.source !== "slack")
+        return false;
+    if (!thread.channel.startsWith("D"))
+        return true;
+    return readStoredSlackThreadContext(thread.metadata) !== null;
+}
+function getKnownSlackThread(broker, threadTs) {
+    const thread = broker.db.getThread(threadTs);
+    if (!thread || thread.source !== "slack")
+        return null;
+    return {
+        channelId: thread.channel,
+        context: readStoredSlackThreadContext(thread.metadata),
+    };
+}
+function rememberKnownSlackThread(broker, threadTs, channelId, context) {
+    const existingMetadata = broker.db.getThread(threadTs)?.metadata ?? {};
+    broker.db.updateThread(threadTs, {
+        source: "slack",
+        channel: channelId,
+        metadata: {
+            ...existingMetadata,
+            ...(context ? { slackThreadContext: context } : {}),
+        },
+    });
+}
+export function createSlackPinetRuntimeAdapterFactory(deps) {
+    return ({ broker, ctx }) => {
+        const settings = deps.getSettings();
+        const allowedUsers = deps.getAllowedUsers();
+        const adapter = new SlackAdapter({
+            botToken: deps.getBotToken(),
+            appToken: deps.getAppToken(),
+            allowedUsers: allowedUsers ? [...allowedUsers] : undefined,
+            allowAllWorkspaceUsers: deps.shouldAllowAllWorkspaceUsers(),
+            suggestedPrompts: settings.suggestedPrompts,
+            reactionCommands: settings.reactionCommands,
+            isKnownThread: (threadTs) => shouldRouteKnownSlackThread(broker.db.getThread(threadTs)),
+            getKnownThread: (threadTs) => getKnownSlackThread(broker, threadTs),
+            rememberKnownThread: (threadTs, channelId, context) => {
+                rememberKnownSlackThread(broker, threadTs, channelId, context);
+            },
+            onAppHomeOpened: async ({ userId }) => {
+                await deps.onAppHomeOpened(userId, ctx);
+            },
+        });
+        return {
+            adapter,
+            getBotUserId: () => adapter.getBotUserId(),
+        };
+    };
+}

package/dist/slack-presence.d.ts

@@ -0,0 +1,36 @@
+export interface SlackPresenceDirectoryUser {
+    id?: string;
+    name?: string;
+    real_name?: string;
+    deleted?: boolean;
+    profile?: {
+        display_name?: string;
+        real_name?: string;
+    };
+}
+export interface SlackPresenceSnapshot {
+    userId: string;
+    userName: string;
+    presence: string;
+    dndEnabled: boolean;
+    dndEndTs?: number;
+    dndEndAt?: string;
+    autoAway?: boolean;
+    manualAway?: boolean;
+    connectionCount?: number;
+    lastActivity?: number;
+    online?: boolean;
+}
+export interface SlackDndInfoLike {
+    dnd_enabled?: unknown;
+    next_dnd_end_ts?: unknown;
+    snooze_enabled?: unknown;
+    snooze_endtime?: unknown;
+}
+export declare function stripSlackUserReference(value: string): string;
+export declare function isSlackUserId(value: string): boolean;
+export declare function getBestSlackPresenceUserName(user: SlackPresenceDirectoryUser): string;
+export declare function findSlackPresenceDirectoryUser(users: SlackPresenceDirectoryUser[], identifier: string): SlackPresenceDirectoryUser | null;
+export declare function resolveSlackPresenceDndEndTs(dndInfo: SlackDndInfoLike): number | undefined;
+export declare function formatSlackPresenceTimestamp(ts: number | undefined): string | undefined;
+export declare function formatSlackPresenceLine(snapshot: SlackPresenceSnapshot): string;

package/dist/slack-presence.js

@@ -0,0 +1,89 @@
+export function stripSlackUserReference(value) {
+    const trimmed = value.trim();
+    const mentionMatch = trimmed.match(/^<@([A-Z0-9]+)>$/i);
+    if (mentionMatch?.[1]) {
+        return mentionMatch[1];
+    }
+    return trimmed.replace(/^@/, "").trim();
+}
+export function isSlackUserId(value) {
+    return /^[UW][A-Z0-9]{2,}$/i.test(stripSlackUserReference(value));
+}
+export function getBestSlackPresenceUserName(user) {
+    const displayName = user.profile?.display_name?.trim();
+    if (displayName)
+        return displayName;
+    const realName = user.real_name?.trim() ?? user.profile?.real_name?.trim();
+    if (realName)
+        return realName;
+    const handle = user.name?.trim();
+    if (handle)
+        return handle;
+    return user.id?.trim() || "unknown-user";
+}
+function normalizeLookupValue(value) {
+    return stripSlackUserReference(value).trim().toLowerCase();
+}
+export function findSlackPresenceDirectoryUser(users, identifier) {
+    const normalized = normalizeLookupValue(identifier);
+    if (!normalized)
+        return null;
+    for (const user of users) {
+        if (user.deleted)
+            continue;
+        const candidates = [
+            user.id,
+            user.name,
+            user.real_name,
+            user.profile?.display_name,
+            user.profile?.real_name,
+        ]
+            .map((value) => value?.trim())
+            .filter((value) => Boolean(value))
+            .map((value) => value.toLowerCase());
+        if (candidates.includes(normalized)) {
+            return user;
+        }
+    }
+    return null;
+}
+function parsePositiveTs(value) {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+export function resolveSlackPresenceDndEndTs(dndInfo) {
+    if (dndInfo.snooze_enabled === true) {
+        return parsePositiveTs(dndInfo.snooze_endtime);
+    }
+    if (dndInfo.dnd_enabled === true) {
+        return parsePositiveTs(dndInfo.next_dnd_end_ts);
+    }
+    return undefined;
+}
+export function formatSlackPresenceTimestamp(ts) {
+    if (ts == null || !Number.isFinite(ts) || ts <= 0) {
+        return undefined;
+    }
+    return new Date(ts * 1000).toISOString();
+}
+export function formatSlackPresenceLine(snapshot) {
+    const segments = [`${snapshot.userName} (${snapshot.userId})`, `presence: ${snapshot.presence}`];
+    if (snapshot.dndEnabled) {
+        segments.push(snapshot.dndEndAt ? `DND: on until ${snapshot.dndEndAt}` : "DND: on (end time unknown)");
+    }
+    else {
+        segments.push("DND: off");
+    }
+    if (snapshot.online != null) {
+        segments.push(`online: ${snapshot.online ? "yes" : "no"}`);
+    }
+    return segments.join(" | ");
+}

package/dist/slack-request-runtime.d.ts

@@ -0,0 +1,8 @@
+import { type SlackResult } from "./slack-api.js";
+export type SlackRequestCall = (method: string, token: string, body?: Record<string, unknown>) => Promise<SlackResult>;
+export interface SlackRequestRuntime {
+    slack: SlackRequestCall;
+    reset: () => void;
+    abortAndWait: () => Promise<void>;
+}
+export declare function createSlackRequestRuntime(): SlackRequestRuntime;

package/dist/slack-request-runtime.js

@@ -0,0 +1,19 @@
+import { createAbortableOperationTracker } from "./helpers.js";
+import { callSlackApi } from "./slack-api.js";
+export function createSlackRequestRuntime() {
+    let slackRequests = createAbortableOperationTracker();
+    const slack = async (method, token, body) => {
+        return slackRequests.run((signal) => callSlackApi(method, token, body, { signal }));
+    };
+    function reset() {
+        slackRequests = createAbortableOperationTracker();
+    }
+    async function abortAndWait() {
+        await slackRequests.abortAndWait();
+    }
+    return {
+        slack,
+        reset,
+        abortAndWait,
+    };
+}

package/dist/slack-runtime-access.d.ts

@@ -0,0 +1,28 @@
+import { type SlackAccessCache, type SlackCall, type SlackSuggestedPrompt } from "./slack-access.js";
+import type { SinglePlayerThreadInfo } from "./single-player-runtime.js";
+export interface SlackRuntimeAccessDeps {
+    slack: SlackCall;
+    getBotToken: () => string;
+    userNames: SlackAccessCache<string, string>;
+    channelCache: SlackAccessCache<string, string>;
+    persistState: () => void;
+    isSinglePlayerShuttingDown: () => boolean;
+    getSuggestedPrompts: () => SlackSuggestedPrompt[] | undefined;
+    getAgentName: () => string;
+    getThreads: () => Map<string, SinglePlayerThreadInfo>;
+    getBrokerRole: () => "broker" | "follower" | null;
+    resolveBrokerThreadChannel?: (threadTs: string) => string | null;
+    resolveFollowerThreadChannel?: (threadTs: string) => Promise<string | null>;
+}
+export interface SlackRuntimeAccess {
+    addReaction: (channel: string, ts: string, emoji: string) => Promise<void>;
+    removeReaction: (channel: string, ts: string, emoji: string) => Promise<void>;
+    resolveUser: (userId: string) => Promise<string>;
+    rememberChannel: (name: string, channelId: string) => void;
+    resolveChannel: (nameOrId: string) => Promise<string>;
+    resolveFollowerReplyChannel: (threadTs: string | undefined) => Promise<string | null>;
+    clearThreadStatus: (channelId: string, threadTs: string) => Promise<void>;
+    setSuggestedPrompts: (channelId: string, threadTs: string) => Promise<void>;
+    fetchSlackMessageByTs: (channel: string, messageTs: string) => Promise<Record<string, unknown> | null>;
+}
+export declare function createSlackRuntimeAccess(deps: SlackRuntimeAccessDeps): SlackRuntimeAccess;

package/dist/slack-runtime-access.js

@@ -0,0 +1,107 @@
+import { resolveFollowerThreadChannel as resolveFollowerThreadChannelState } from "./helpers.js";
+import { addSlackReaction, clearSlackThreadStatus, fetchSlackMessageByTs as fetchSlackMessageByTsFromSlack, removeSlackReaction, resolveSlackChannelId, resolveSlackUserName, setSlackSuggestedPrompts, } from "./slack-access.js";
+export function createSlackRuntimeAccess(deps) {
+    return {
+        addReaction: async (channel, ts, emoji) => {
+            await addSlackReaction({
+                slack: deps.slack,
+                token: deps.getBotToken(),
+                channel,
+                timestamp: ts,
+                emoji,
+            });
+        },
+        removeReaction: async (channel, ts, emoji) => {
+            await removeSlackReaction({
+                slack: deps.slack,
+                token: deps.getBotToken(),
+                channel,
+                timestamp: ts,
+                emoji,
+            });
+        },
+        resolveUser: async (userId) => {
+            const hadCachedUser = deps.userNames.get(userId) != null;
+            const name = await resolveSlackUserName({
+                slack: deps.slack,
+                token: deps.getBotToken(),
+                userId,
+                cache: deps.userNames,
+                shouldUseResult: () => !deps.isSinglePlayerShuttingDown(),
+            });
+            if (!hadCachedUser && deps.userNames.get(userId) != null) {
+                deps.persistState();
+            }
+            return name;
+        },
+        rememberChannel: (name, channelId) => {
+            deps.channelCache.set(name.replace(/^#/, ""), channelId);
+        },
+        resolveChannel: async (nameOrId) => {
+            return resolveSlackChannelId({
+                slack: deps.slack,
+                token: deps.getBotToken(),
+                nameOrId,
+                cache: deps.channelCache,
+            });
+        },
+        resolveFollowerReplyChannel: async (threadTs) => {
+            if (!threadTs) {
+                return null;
+            }
+            const threads = deps.getThreads();
+            const existingThread = threads.get(threadTs);
+            const brokerRole = deps.getBrokerRole();
+            const resolveThread = brokerRole === "broker"
+                ? async (nextThreadTs) => deps.resolveBrokerThreadChannel?.(nextThreadTs) ?? null
+                : brokerRole === "follower"
+                    ? deps.resolveFollowerThreadChannel
+                    : undefined;
+            const resolved = await resolveFollowerThreadChannelState(threadTs, existingThread, resolveThread);
+            if (resolved.threadUpdate && resolved.changed) {
+                threads.set(threadTs, {
+                    ...(existingThread ?? {}),
+                    ...resolved.threadUpdate,
+                });
+                deps.persistState();
+            }
+            return resolved.channelId;
+        },
+        clearThreadStatus: async (channelId, threadTs) => {
+            await clearSlackThreadStatus({
+                slack: deps.slack,
+                token: deps.getBotToken(),
+                channelId,
+                threadTs,
+            });
+        },
+        setSuggestedPrompts: async (channelId, threadTs) => {
+            const prompts = deps.getSuggestedPrompts() ?? [
+                {
+                    title: "Status",
+                    message: `Hey ${deps.getAgentName()}, what are you working on right now?`,
+                },
+                {
+                    title: "Help",
+                    message: `${deps.getAgentName()}, I need help with something in the codebase`,
+                },
+                { title: "Review", message: `${deps.getAgentName()}, summarise the recent changes` },
+            ];
+            await setSlackSuggestedPrompts({
+                slack: deps.slack,
+                token: deps.getBotToken(),
+                channelId,
+                threadTs,
+                prompts,
+            });
+        },
+        fetchSlackMessageByTs: async (channel, messageTs) => {
+            return fetchSlackMessageByTsFromSlack({
+                slack: deps.slack,
+                token: deps.getBotToken(),
+                channel,
+                messageTs,
+            });
+        },
+    };
+}

package/dist/slack-scope-diagnostics.d.ts

@@ -0,0 +1,31 @@
+export type SlackScopeDiagnosticsStatus = "not_checked" | "pending" | "healthy" | "drift" | "unavailable";
+export interface SlackScopeProbeResult {
+    key: string;
+    surface: "files" | "bookmarks" | "pins";
+    method: string;
+    expectedScopes: string[];
+    status: "ok" | "missing" | "unavailable";
+    missingScopes: string[];
+    error?: string;
+    neededScopes?: string[];
+    providedScopes?: string[];
+}
+export interface SlackScopeDiagnostics {
+    status: SlackScopeDiagnosticsStatus;
+    checkedAt: string | null;
+    summary: string;
+    surfaces: Array<"files" | "bookmarks" | "pins">;
+    missingScopes: string[];
+    results: SlackScopeProbeResult[];
+    error?: string;
+}
+export interface DetectSlackScopeDiagnosticsOptions {
+    token: string;
+    fetchImpl?: typeof fetch;
+    now?: () => string;
+}
+export declare function createUncheckedSlackScopeDiagnostics(): SlackScopeDiagnostics;
+export declare function createPendingSlackScopeDiagnostics(): SlackScopeDiagnostics;
+export declare function detectSlackScopeDiagnostics(options: DetectSlackScopeDiagnosticsOptions): Promise<SlackScopeDiagnostics>;
+export declare function formatSlackScopeDiagnosticsStatus(diagnostics: SlackScopeDiagnostics): string;
+export declare function buildSlackScopeDriftWarning(diagnostics: SlackScopeDiagnostics): string | null;