@pinet/slack-bridge 0.1.0

package/dist/runtime-mode.js

@@ -0,0 +1,39 @@
+export function normalizeSlackBridgeRuntimeMode(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "off" ||
+        normalized === "single" ||
+        normalized === "broker" ||
+        normalized === "follower") {
+        return normalized;
+    }
+    return null;
+}
+export function isPinetRuntimeMode(mode) {
+    return mode === "broker" || mode === "follower";
+}
+export function isBrokerManagedFollowerLaunch(env = process.env) {
+    return env.PINET_BROKER_MANAGED === "1" && env.PINET_LAUNCH_SOURCE === "broker-tmux";
+}
+export function resolveSlackBridgeStartupRuntimeMode(settings, options = {}) {
+    const explicitMode = normalizeSlackBridgeRuntimeMode(settings.runtimeMode);
+    const brokerSocketExists = options.brokerSocketExists ?? true;
+    if (options.brokerManagedFollowerLaunch) {
+        if (explicitMode === "follower" || (!explicitMode && settings.autoFollow)) {
+            return brokerSocketExists ? "follower" : "off";
+        }
+        return "off";
+    }
+    if (explicitMode) {
+        if (explicitMode === "follower" && !brokerSocketExists) {
+            return "off";
+        }
+        return explicitMode;
+    }
+    if (settings.autoFollow) {
+        return brokerSocketExists ? "follower" : "off";
+    }
+    if (settings.autoConnect) {
+        return "single";
+    }
+    return "off";
+}

package/dist/scheduled-wakeups.d.ts

@@ -0,0 +1 @@
+export { buildScheduledWakeupThreadId, parseScheduledWakeupDelay, resolveScheduledWakeupFireAt, type ScheduledWakeupInput, } from "@pinet/pinet-core/scheduled-wakeups";

package/dist/scheduled-wakeups.js

@@ -0,0 +1 @@
+export { buildScheduledWakeupThreadId, parseScheduledWakeupDelay, resolveScheduledWakeupFireAt, } from "@pinet/pinet-core/scheduled-wakeups";

package/dist/session-ui-runtime.d.ts

@@ -0,0 +1,20 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+export type SessionUiStatusState = "ok" | "reconnecting" | "error" | "off";
+export interface SessionUiRuntimeDeps {
+    getAgentName: () => string;
+    getAgentEmoji: () => string;
+    getInboxLength: () => number;
+    drainInbox: () => void;
+}
+export interface SessionUiRuntime {
+    getExtensionContext: () => ExtensionContext | null;
+    setExtCtx: (ctx: ExtensionContext) => void;
+    updateBadge: () => void;
+    setExtStatus: (ctx: ExtensionContext, state: SessionUiStatusState) => void;
+    notePotentialInterruptInput: (data: string) => void;
+    shouldSuppressAutomaticInboxDrain: (now?: number) => boolean;
+    maybeDrainInboxIfIdle: (ctx?: ExtensionContext) => boolean;
+    prepareForSessionStart: (ctx: ExtensionContext) => void;
+    cleanupForSessionShutdown: () => void;
+}
+export declare function createSessionUiRuntime(deps: SessionUiRuntimeDeps): SessionUiRuntime;

package/dist/session-ui-runtime.js

@@ -0,0 +1,163 @@
+const AUTO_DRAIN_INTERRUPT_SUPPRESSION_MS = 1_500;
+const AUTO_DRAIN_IDLE_RETRY_MS = 250;
+const ESCAPE_SEQUENCE = "\u001b";
+const ESCAPE_CODEPOINT = 27;
+const KITTY_LOCK_MODIFIER_MASK = 64 + 128; // Caps Lock + Num Lock.
+function isUnmodifiedEscapeInput(data) {
+    // Pi enables Kitty keyboard protocol or xterm modifyOtherKeys when available, so
+    // plain Escape may arrive as an encoded key event rather than a raw ESC byte.
+    if (data === ESCAPE_SEQUENCE) {
+        return true;
+    }
+    return isUnmodifiedKittyEscapeInput(data) || isUnmodifiedModifyOtherKeysEscapeInput(data);
+}
+function isUnmodifiedKittyEscapeInput(data) {
+    if (!data.startsWith(`${ESCAPE_SEQUENCE}[`) || !data.endsWith("u")) {
+        return false;
+    }
+    const body = data.slice(2, -1);
+    const [codepointWithAlternateKeys, modifierWithEventType, ...extraParts] = body.split(";");
+    if (!codepointWithAlternateKeys || extraParts.length > 0) {
+        return false;
+    }
+    const codepoint = Number.parseInt(codepointWithAlternateKeys.split(":")[0] ?? "", 10);
+    const modifierValue = Number.parseInt(modifierWithEventType?.split(":")[0] ?? "1", 10);
+    return (codepoint === ESCAPE_CODEPOINT &&
+        Number.isFinite(modifierValue) &&
+        ((modifierValue - 1) & ~KITTY_LOCK_MODIFIER_MASK) === 0);
+}
+function isUnmodifiedModifyOtherKeysEscapeInput(data) {
+    if (!data.startsWith(`${ESCAPE_SEQUENCE}[`) || !data.endsWith("~")) {
+        return false;
+    }
+    const body = data.slice(2, -1);
+    const [prefix, modifier, codepoint, ...extraParts] = body.split(";");
+    if (prefix !== "27" || codepoint !== "27" || extraParts.length > 0) {
+        return false;
+    }
+    const modifierValue = Number.parseInt(modifier ?? "", 10);
+    return Number.isFinite(modifierValue) && ((modifierValue - 1) & ~KITTY_LOCK_MODIFIER_MASK) === 0;
+}
+export function createSessionUiRuntime(deps) {
+    let suppressAutoDrainUntil = 0;
+    let terminalInputUnsubscribe = null;
+    let deferredDrainTimer = null;
+    let extCtx = null;
+    function getExtensionContext() {
+        return extCtx;
+    }
+    function setExtCtx(ctx) {
+        extCtx = ctx;
+    }
+    function updateBadge() {
+        if (!extCtx?.hasUI)
+            return;
+        const t = extCtx.ui.theme;
+        const n = deps.getInboxLength();
+        const label = n > 0
+            ? t.fg("accent", `${deps.getAgentEmoji()} ${deps.getAgentName()} ✦ ${n}`)
+            : t.fg("accent", `${deps.getAgentEmoji()} ${deps.getAgentName()} ✦`);
+        extCtx.ui.setStatus("slack-bridge", label);
+    }
+    function setExtStatus(ctx, state) {
+        if (!ctx.hasUI)
+            return;
+        extCtx = ctx;
+        const t = ctx.ui.theme;
+        if (state === "ok") {
+            updateBadge();
+            return;
+        }
+        const text = state === "reconnecting"
+            ? t.fg("warning", `${deps.getAgentEmoji()} ${deps.getAgentName()} ⟳`)
+            : state === "error"
+                ? t.fg("error", `${deps.getAgentEmoji()} ${deps.getAgentName()} ✗`)
+                : "";
+        ctx.ui.setStatus("slack-bridge", text);
+    }
+    function notePotentialInterruptInput(data) {
+        if (!isUnmodifiedEscapeInput(data)) {
+            return;
+        }
+        suppressAutoDrainUntil = Math.max(suppressAutoDrainUntil, Date.now() + AUTO_DRAIN_INTERRUPT_SUPPRESSION_MS);
+    }
+    function shouldSuppressAutomaticInboxDrain(now = Date.now()) {
+        if (suppressAutoDrainUntil === 0) {
+            return false;
+        }
+        if (now >= suppressAutoDrainUntil) {
+            suppressAutoDrainUntil = 0;
+            return false;
+        }
+        return true;
+    }
+    function clearDeferredDrainTimer() {
+        if (!deferredDrainTimer)
+            return;
+        clearTimeout(deferredDrainTimer);
+        deferredDrainTimer = null;
+    }
+    function scheduleDeferredDrain(ctx) {
+        extCtx = ctx;
+        if (deferredDrainTimer)
+            return;
+        deferredDrainTimer = setTimeout(() => {
+            deferredDrainTimer = null;
+            if (deps.getInboxLength() === 0)
+                return;
+            const latestCtx = extCtx;
+            if (!latestCtx)
+                return;
+            maybeDrainInboxIfIdle(latestCtx);
+        }, AUTO_DRAIN_IDLE_RETRY_MS);
+        deferredDrainTimer.unref?.();
+    }
+    function maybeDrainInboxIfIdle(ctx) {
+        if (ctx) {
+            extCtx = ctx;
+        }
+        const activeCtx = ctx ?? extCtx;
+        if (!(activeCtx?.isIdle?.() ?? false)) {
+            if (activeCtx && !shouldSuppressAutomaticInboxDrain() && deps.getInboxLength() > 0) {
+                scheduleDeferredDrain(activeCtx);
+            }
+            return false;
+        }
+        if (shouldSuppressAutomaticInboxDrain()) {
+            return false;
+        }
+        clearDeferredDrainTimer();
+        deps.drainInbox();
+        return true;
+    }
+    function prepareForSessionStart(ctx) {
+        suppressAutoDrainUntil = 0;
+        terminalInputUnsubscribe?.();
+        terminalInputUnsubscribe = null;
+        extCtx = ctx;
+        const uiWithTerminalInput = ctx.ui;
+        if (ctx.hasUI && typeof uiWithTerminalInput.onTerminalInput === "function") {
+            terminalInputUnsubscribe = uiWithTerminalInput.onTerminalInput((data) => {
+                notePotentialInterruptInput(data);
+                return undefined;
+            });
+        }
+    }
+    function cleanupForSessionShutdown() {
+        terminalInputUnsubscribe?.();
+        terminalInputUnsubscribe = null;
+        clearDeferredDrainTimer();
+        suppressAutoDrainUntil = 0;
+    }
+    return {
+        getExtensionContext,
+        setExtCtx,
+        updateBadge,
+        setExtStatus,
+        notePotentialInterruptInput,
+        shouldSuppressAutomaticInboxDrain,
+        maybeDrainInboxIfIdle,
+        prepareForSessionStart,
+        cleanupForSessionShutdown,
+    };
+}

package/dist/single-player-runtime.d.ts

@@ -0,0 +1,71 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type InboxMessage } from "./helpers.js";
+import { type ReactionCommandTemplate } from "./reaction-triggers.js";
+import type { SlackToolsThreadContextPort } from "./slack-tools.js";
+import { type ParsedThreadStarted, type SlackAccessSet, type SlackCall } from "./slack-access.js";
+export interface SinglePlayerThreadState {
+    channelId: string;
+    threadTs: string;
+    userId: string;
+    source?: string;
+    context?: ParsedThreadStarted["context"];
+    owner?: string;
+}
+export interface SinglePlayerPendingAttention {
+    channel: string;
+    messageTs: string;
+}
+export type SinglePlayerThreadInfo = SinglePlayerThreadState;
+export type SinglePlayerPendingAttentionEntry = SinglePlayerPendingAttention;
+export interface SinglePlayerUnclaimedThreads {
+    has: (threadTs: string) => boolean;
+    add: (threadTs: string) => void;
+    delete: (threadTs: string) => void;
+}
+export interface SinglePlayerRuntimeDeps {
+    slack: SlackCall;
+    getBotToken: () => string;
+    getAppToken: () => string;
+    dedup: SlackAccessSet<string>;
+    abortSlackRequests: () => Promise<void>;
+    isSingleRuntimeActive: () => boolean;
+    setExtStatus: (ctx: ExtensionContext, state: "ok" | "reconnecting" | "error" | "off") => void;
+    formatError: (error: unknown) => string;
+    getAgentName: () => string;
+    getAgentAliases: () => Iterable<string>;
+    getAgentOwnerToken: () => string;
+    getBotUserId: () => string | null;
+    getThreads: () => Map<string, SinglePlayerThreadState>;
+    getPendingEyes: () => Map<string, SinglePlayerPendingAttention[]>;
+    getUnclaimedThreads: () => SinglePlayerUnclaimedThreads;
+    pushInboxMessage: (message: InboxMessage) => void;
+    setLastDmChannel: (channelId: string | null) => void;
+    persistState: () => void;
+    updateBadge: () => void;
+    maybeDrainInboxIfIdle: (ctx: ExtensionContext) => boolean;
+    resolveThreadChannel: (threadTs: string | undefined) => Promise<string | null>;
+    setSuggestedPrompts: (channelId: string, threadTs: string) => Promise<void>;
+    publishCurrentPinetHomeTab: (userId: string, ctx: ExtensionContext) => Promise<void>;
+    fetchSlackMessageByTs: (channel: string, messageTs: string) => Promise<Record<string, unknown> | null>;
+    addReaction: (channel: string, ts: string, emoji: string) => Promise<void>;
+    removeReaction: (channel: string, ts: string, emoji: string) => Promise<void>;
+    resolveUser: (userId: string) => Promise<string>;
+    isUserAllowed: (userId: string) => boolean;
+    getReactionCommand: (reactionName: string) => ReactionCommandTemplate | undefined;
+    consumeConfirmationReply: (threadTs: string, text: string) => {
+        approved: boolean;
+    } | null;
+    claimOwnedThread: (threadTs: string, channelId: string, source?: string) => void;
+    beginThreadStatus?: (channelId: string, threadTs: string, status: string) => Promise<void>;
+}
+export interface SinglePlayerRuntime {
+    connect: (ctx: ExtensionContext) => Promise<void>;
+    disconnect: () => Promise<void>;
+    getBotUserId: () => string | null;
+    isConnected: () => boolean;
+    isShuttingDown: () => boolean;
+    resetShutdownState: () => void;
+    trackOwnedThread: (threadTs: string, channelId: string, source?: string) => void;
+    getThreadContextPort: () => SlackToolsThreadContextPort;
+}
+export declare function createSinglePlayerRuntime(deps: SinglePlayerRuntimeDeps): SinglePlayerRuntime;