@pinet/slack-bridge 0.1.0

package/dist/slack-turn-guardrails.d.ts

@@ -0,0 +1,19 @@
+import type { InboxMessage } from "./helpers.js";
+type SlackTurnMessageRef = Pick<InboxMessage, "threadTs"> & Partial<Pick<InboxMessage, "channel">>;
+export interface PendingSlackToolPolicyTurn {
+    prompt: string;
+    threadTs: string | undefined;
+    channel: string | undefined;
+    threadCount: number;
+}
+export declare function buildPendingSlackToolPolicyTurn(prompt: string, messages: SlackTurnMessageRef[]): PendingSlackToolPolicyTurn;
+export declare function enqueuePendingSlackToolPolicyTurn(queue: PendingSlackToolPolicyTurn[], prompt: string, messages: SlackTurnMessageRef[]): PendingSlackToolPolicyTurn;
+export declare function consumePendingSlackToolPolicyTurn(queue: PendingSlackToolPolicyTurn[], text: string): PendingSlackToolPolicyTurn | null;
+export declare function removePendingSlackToolPolicyTurn(queue: PendingSlackToolPolicyTurn[], entry: PendingSlackToolPolicyTurn): void;
+export declare function deliverTrackedSlackFollowUpMessage(options: {
+    queue: PendingSlackToolPolicyTurn[];
+    prompt: string;
+    messages: SlackTurnMessageRef[];
+    deliver: (prompt: string) => boolean;
+}): boolean;
+export {};

package/dist/slack-turn-guardrails.js

@@ -0,0 +1,36 @@
+export function buildPendingSlackToolPolicyTurn(prompt, messages) {
+    const threadIds = [...new Set(messages.map((message) => message.threadTs).filter(Boolean))];
+    const channels = [...new Set(messages.map((message) => message.channel).filter(Boolean))];
+    return {
+        prompt,
+        threadTs: threadIds.length === 1 ? threadIds[0] : undefined,
+        channel: channels.length === 1 ? channels[0] : undefined,
+        threadCount: threadIds.length,
+    };
+}
+export function enqueuePendingSlackToolPolicyTurn(queue, prompt, messages) {
+    const entry = buildPendingSlackToolPolicyTurn(prompt, messages);
+    queue.push(entry);
+    return entry;
+}
+export function consumePendingSlackToolPolicyTurn(queue, text) {
+    const index = queue.findIndex((entry) => entry.prompt === text);
+    if (index < 0)
+        return null;
+    const [entry] = queue.splice(index, 1);
+    return entry ?? null;
+}
+export function removePendingSlackToolPolicyTurn(queue, entry) {
+    const index = queue.indexOf(entry);
+    if (index >= 0) {
+        queue.splice(index, 1);
+    }
+}
+export function deliverTrackedSlackFollowUpMessage(options) {
+    const entry = enqueuePendingSlackToolPolicyTurn(options.queue, options.prompt, options.messages);
+    if (options.deliver(options.prompt)) {
+        return true;
+    }
+    removePendingSlackToolPolicyTurn(options.queue, entry);
+    return false;
+}

package/dist/slack-upload.d.ts

@@ -0,0 +1,49 @@
+import { readFile, realpath, stat } from "node:fs/promises";
+import type { SlackResult } from "./slack-api.js";
+export interface SlackUploadParams {
+    content?: string;
+    path?: string;
+    filename?: string;
+    filetype?: string;
+    title?: string;
+}
+export interface PreparedSlackUpload {
+    bytes: Buffer;
+    byteLength: number;
+    filename: string;
+    title: string;
+    filetype?: string;
+    snippetType?: string;
+    source: "content" | "path";
+    resolvedPath?: string;
+}
+export interface SlackUploadDeps {
+    slack: (method: string, token: string, body?: Record<string, unknown>) => Promise<SlackResult>;
+    token: string;
+    fetchImpl?: (url: string, init: RequestInit) => Promise<Pick<Response, "ok" | "status" | "statusText" | "text">>;
+}
+export interface PerformSlackUploadOptions extends SlackUploadDeps {
+    upload: PreparedSlackUpload;
+    channelId: string;
+    threadTs?: string;
+}
+export interface CompletedSlackUpload {
+    fileId: string;
+    response: SlackResult;
+}
+interface PrepareSlackUploadFs {
+    readFileImpl?: typeof readFile;
+    realpathImpl?: typeof realpath;
+    statImpl?: typeof stat;
+}
+export declare function inferSlackUploadFiletype(filename: string | undefined, explicitFiletype?: string): string | undefined;
+export declare function chooseSlackSnippetType(upload: {
+    source: "content" | "path";
+    byteLength: number;
+    filename: string;
+    filetype?: string;
+}): string | undefined;
+export declare function resolveSlackUploadPath(inputPath: string, cwd: string, tmpdir: string, fsDeps?: PrepareSlackUploadFs): Promise<string>;
+export declare function prepareSlackUpload(params: SlackUploadParams, cwd: string, tmpdir: string, fsDeps?: PrepareSlackUploadFs): Promise<PreparedSlackUpload>;
+export declare function performSlackUpload({ upload, channelId, threadTs, slack, token, fetchImpl, }: PerformSlackUploadOptions): Promise<CompletedSlackUpload>;
+export {};

package/dist/slack-upload.js

@@ -0,0 +1,224 @@
+import { readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+const FILETYPE_ALIASES = {
+    cjs: "javascript",
+    htm: "html",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    md: "markdown",
+    py: "python",
+    rb: "ruby",
+    sh: "shell",
+    ts: "typescript",
+    tsx: "typescript",
+    yml: "yaml",
+    zsh: "shell",
+};
+const DEFAULT_SNIPPET_TYPE = "text";
+const MAX_SNIPPET_BYTES = 1_000_000;
+export function inferSlackUploadFiletype(filename, explicitFiletype) {
+    const raw = (explicitFiletype ?? path.extname(filename ?? "").slice(1)).trim().toLowerCase();
+    if (!raw)
+        return undefined;
+    return FILETYPE_ALIASES[raw] ?? raw;
+}
+export function chooseSlackSnippetType(upload) {
+    if (upload.source !== "content")
+        return undefined;
+    if (upload.byteLength > MAX_SNIPPET_BYTES)
+        return undefined;
+    return normalizeSnippetType(inferSlackUploadFiletype(upload.filename, upload.filetype));
+}
+function isWithinRoot(candidate, root) {
+    return candidate === root || candidate.startsWith(`${root}${path.sep}`);
+}
+function normalizeSnippetType(filetype) {
+    return filetype?.trim().toLowerCase() || DEFAULT_SNIPPET_TYPE;
+}
+function buildUploadMetadataPayload(upload, includeSnippetType) {
+    return {
+        filename: upload.filename,
+        length: upload.byteLength,
+        ...(includeSnippetType && upload.snippetType ? { snippet_type: upload.snippetType } : {}),
+    };
+}
+function isInvalidUploadMetadataError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const lower = error.message.toLowerCase();
+    return lower.includes("files.getuploadurlexternal") && lower.includes("invalid_arguments");
+}
+function formatUploadMetadataRetryError(upload, retryError, originalError) {
+    return new Error(`Slack files.getUploadURLExternal: invalid_arguments after retry without snippet_type; Slack rejected upload metadata for filename=${JSON.stringify(upload.filename)} byte_length=${upload.byteLength}. retry_error=${formatUploadError(retryError)}; original_error=${formatUploadError(originalError)}`);
+}
+function getUploadHost(uploadUrl) {
+    try {
+        return new URL(uploadUrl).hostname || "<unknown>";
+    }
+    catch {
+        return "<unknown>";
+    }
+}
+function formatUploadError(error) {
+    if (error instanceof Error) {
+        if (typeof error.cause === "string") {
+            return `${error.message}; cause: ${error.cause}`;
+        }
+        if (error.cause instanceof Error) {
+            const cause = [
+                error.cause.message,
+                error.cause.code,
+                error.cause.name,
+            ]
+                .filter((value) => typeof value === "string" && value.length > 0)
+                .join("; ");
+            return cause ? `${error.message}; cause: ${cause}` : error.message;
+        }
+        return error.message;
+    }
+    return String(error);
+}
+function isLikelyProxyOrFirewallFailure(responseText, headers) {
+    const headerText = [
+        headers?.get("x-proxy-error"),
+        headers?.get("x-proxy-status"),
+        headers?.get("via"),
+        headers?.get("server"),
+    ]
+        .filter((value) => typeof value === "string")
+        .join(" ");
+    const combined = `${responseText} ${headerText}`.toLowerCase();
+    return /(blocked-by-allowlist|possible outbound proxy|blocked by proxy|proxy-firewall|firewall)/.test(combined);
+}
+export async function resolveSlackUploadPath(inputPath, cwd, tmpdir, fsDeps = {}) {
+    const { realpathImpl = realpath, statImpl = stat } = fsDeps;
+    const requestedPath = inputPath.trim();
+    if (!requestedPath) {
+        throw new Error("path is required when uploading from a local file.");
+    }
+    const candidate = path.isAbsolute(requestedPath)
+        ? requestedPath
+        : path.resolve(cwd, requestedPath);
+    const [resolvedCandidate, resolvedCwd, resolvedTmpdir] = await Promise.all([
+        realpathImpl(candidate),
+        realpathImpl(cwd),
+        realpathImpl(tmpdir),
+    ]);
+    if (!isWithinRoot(resolvedCandidate, resolvedCwd) &&
+        !isWithinRoot(resolvedCandidate, resolvedTmpdir)) {
+        throw new Error("For safety, the slack dispatcher upload action only allows local file paths inside the current working directory or the system temp directory. For other files, read the content explicitly and upload it via the content parameter.");
+    }
+    const fileStats = await statImpl(resolvedCandidate);
+    if (!fileStats.isFile()) {
+        throw new Error(`Local upload path is not a file: ${requestedPath}`);
+    }
+    return resolvedCandidate;
+}
+export async function prepareSlackUpload(params, cwd, tmpdir, fsDeps = {}) {
+    const { readFileImpl = readFile } = fsDeps;
+    const hasContent = typeof params.content === "string";
+    const hasPath = typeof params.path === "string" && params.path.trim().length > 0;
+    if (hasContent === hasPath) {
+        throw new Error("Provide exactly one of content or path.");
+    }
+    let bytes;
+    let filename = params.filename?.trim();
+    let resolvedPath;
+    let source;
+    if (hasContent) {
+        if (!filename) {
+            throw new Error("filename is required when uploading inline content.");
+        }
+        bytes = Buffer.from(params.content ?? "", "utf8");
+        source = "content";
+    }
+    else {
+        resolvedPath = await resolveSlackUploadPath(params.path, cwd, tmpdir, fsDeps);
+        bytes = await readFileImpl(resolvedPath);
+        filename = filename || path.basename(resolvedPath);
+        source = "path";
+    }
+    const sanitizedFilename = filename?.trim();
+    if (!sanitizedFilename) {
+        throw new Error("filename is required.");
+    }
+    const filetype = inferSlackUploadFiletype(sanitizedFilename, params.filetype);
+    const title = params.title?.trim() || sanitizedFilename;
+    return {
+        bytes,
+        byteLength: bytes.byteLength,
+        filename: sanitizedFilename,
+        title,
+        filetype,
+        snippetType: chooseSlackSnippetType({
+            source,
+            byteLength: bytes.byteLength,
+            filename: sanitizedFilename,
+            filetype,
+        }),
+        source,
+        ...(resolvedPath ? { resolvedPath } : {}),
+    };
+}
+export async function performSlackUpload({ upload, channelId, threadTs, slack, token, fetchImpl = fetch, }) {
+    let getUploadResponse;
+    try {
+        getUploadResponse = await slack("files.getUploadURLExternal", token, buildUploadMetadataPayload(upload, true));
+    }
+    catch (error) {
+        if (upload.snippetType && isInvalidUploadMetadataError(error)) {
+            try {
+                getUploadResponse = await slack("files.getUploadURLExternal", token, buildUploadMetadataPayload(upload, false));
+            }
+            catch (retryError) {
+                if (isInvalidUploadMetadataError(retryError)) {
+                    throw formatUploadMetadataRetryError(upload, retryError, error);
+                }
+                throw retryError;
+            }
+        }
+        else {
+            throw error;
+        }
+    }
+    const uploadUrl = typeof getUploadResponse.upload_url === "string" ? getUploadResponse.upload_url : null;
+    const uploadHost = uploadUrl ? getUploadHost(uploadUrl) : "<unknown>";
+    const fileId = typeof getUploadResponse.file_id === "string" ? getUploadResponse.file_id : null;
+    if (!uploadUrl || !fileId) {
+        throw new Error("Slack files.getUploadURLExternal did not return an upload URL and file ID.");
+    }
+    const rawBody = new Uint8Array(upload.bytes.byteLength);
+    rawBody.set(upload.bytes);
+    let rawUploadResponse;
+    try {
+        rawUploadResponse = await fetchImpl(uploadUrl, {
+            method: "POST",
+            headers: {
+                "Content-Length": String(upload.byteLength),
+                "Content-Type": upload.source === "content" ? "text/plain; charset=utf-8" : "application/octet-stream",
+            },
+            body: new Blob([rawBody]),
+        });
+    }
+    catch (error) {
+        throw new Error(`Slack raw upload failed (transport): ${formatUploadError(error)}; host=${uploadHost}; filename=${upload.filename} byte_length=${upload.byteLength}`);
+    }
+    if (!rawUploadResponse.ok) {
+        const details = (await rawUploadResponse.text()).trim();
+        const statusText = rawUploadResponse.statusText;
+        const statusTextForHeader = statusText ? ` ${statusText}` : "";
+        const withDetails = details.length > 0 ? `${statusText ? `${statusText}: ` : ""}${details}` : "";
+        const rawUploadResponseHeaders = rawUploadResponse.headers instanceof Headers ? rawUploadResponse.headers : undefined;
+        const isProxyOrFirewallFailure = isLikelyProxyOrFirewallFailure(details, rawUploadResponseHeaders);
+        const hint = isProxyOrFirewallFailure ? " [possible outbound proxy/firewall block]" : "";
+        throw new Error(`Slack raw upload failed (HTTP ${rawUploadResponse.status}${statusTextForHeader})${withDetails ? ` ${withDetails}` : ""}${hint}; host=${uploadHost}; filename=${upload.filename} byte_length=${upload.byteLength}`);
+    }
+    const response = await slack("files.completeUploadExternal", token, {
+        files: [{ id: fileId, title: upload.title }],
+        channel_id: channelId,
+        ...(threadTs ? { thread_ts: threadTs } : {}),
+    });
+    return { fileId, response };
+}

package/dist/task-assignments.d.ts

@@ -0,0 +1,45 @@
+import type { AgentInfo, TaskAssignmentInfo, TaskAssignmentKind, TaskAssignmentStatus } from "./broker/types.js";
+export type CommandResult = {
+    stdout?: string | Buffer;
+};
+export type CommandRunner = (file: string, args: string[], options: {
+    cwd: string;
+    encoding: "utf-8";
+}) => Promise<CommandResult>;
+export interface ParsedTaskAssignment {
+    issueNumber: number;
+    branch: string | null;
+    repoOwner: string | null;
+    repoName: string | null;
+    taskKind: TaskAssignmentKind;
+}
+export interface PullRequestSnapshot {
+    number: number;
+    state: string;
+    mergedAt: string | null;
+    headRefName: string;
+}
+export interface IssueSnapshot {
+    number: number;
+    state: string;
+}
+export interface ResolvedTaskAssignment extends TaskAssignmentInfo {
+    nextStatus: TaskAssignmentStatus;
+    nextPrNumber: number | null;
+    branchAheadCount: number;
+    issueState: "OPEN" | "CLOSED" | null;
+}
+export declare function extractTaskAssignmentsFromMessage(message: string): ParsedTaskAssignment[];
+export declare function normalizeTrackedTaskAssignments(assignments: TaskAssignmentInfo[], sourceMessagesById?: ReadonlyMap<number, string>): TaskAssignmentInfo[];
+export declare function resolveTaskAssignments(assignments: TaskAssignmentInfo[], cwd?: string, runner?: CommandRunner): Promise<ResolvedTaskAssignment[]>;
+export declare function hasTaskAssignmentStatusChange(assignment: ResolvedTaskAssignment): boolean;
+type ReportableTaskAssignment = Pick<TaskAssignmentInfo, "agentId" | "issueNumber" | "branch" | "status" | "prNumber" | "taskKind" | "repoOwner" | "repoName" | "repoRoot"> & {
+    issueState?: ResolvedTaskAssignment["issueState"];
+};
+export declare function buildTaskAssignmentReport(assignments: ReportableTaskAssignment[], agentsById: ReadonlyMap<string, Pick<AgentInfo, "emoji" | "name">>, cycleStartedAt?: string): string | null;
+export interface PendingTaskAssignmentReport {
+    message: string;
+    signature: string;
+}
+export declare function getPendingTaskAssignmentReport(assignments: ReportableTaskAssignment[], agentsById: ReadonlyMap<string, Pick<AgentInfo, "emoji" | "name">>, lastDeliveredSignature: string, cycleStartedAt?: string): PendingTaskAssignmentReport | null;
+export {};