@pinet/slack-bridge 0.1.0

package/dist/persisted-runtime-state.d.ts

@@ -0,0 +1,52 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type SlackBridgeSettings } from "./helpers.js";
+import type { SinglePlayerThreadInfo } from "./single-player-runtime.js";
+export interface PersistedState {
+    threads?: [string, SinglePlayerThreadInfo][];
+    lastDmChannel?: string | null;
+    userNames?: [string, string][];
+    agentName?: string;
+    agentEmoji?: string;
+    agentStableId?: string;
+    brokerStableId?: string;
+    lastPinetRole?: "broker" | "worker";
+    activeSkinTheme?: string | null;
+    agentPersonality?: string | null;
+    agentAliases?: string[];
+}
+export interface PersistedRuntimeStateStringCache {
+    entries: () => Iterable<[string, string]>;
+    has: (key: string) => boolean;
+    set: (key: string, value: string) => void;
+}
+export interface PersistedRuntimeStateDeps {
+    pi: Pick<ExtensionAPI, "appendEntry">;
+    threads: Map<string, SinglePlayerThreadInfo>;
+    userNames: PersistedRuntimeStateStringCache;
+    getLastDmChannel: () => string | null;
+    setLastDmChannel: (channelId: string | null) => void;
+    getAgentName: () => string;
+    setAgentName: (name: string) => void;
+    getAgentEmoji: () => string;
+    setAgentEmoji: (emoji: string) => void;
+    getAgentStableId: () => string;
+    setAgentStableId: (stableId: string) => void;
+    getBrokerStableId: () => string;
+    setBrokerStableId: (stableId: string) => void;
+    getBrokerRole: () => "broker" | "follower" | null;
+    getActiveSkinTheme: () => string | null;
+    setActiveSkinTheme: (theme: string | null) => void;
+    getAgentPersonality: () => string | null;
+    setAgentPersonality: (personality: string | null) => void;
+    agentAliases: Set<string>;
+    setAgentOwnerToken: (ownerToken: string) => void;
+    getSettings: () => SlackBridgeSettings;
+    formatError: (error: unknown) => string;
+}
+export interface PersistedRuntimeStateManager {
+    persistStateNow: () => void;
+    persistState: () => void;
+    flushPersist: () => void;
+    restorePersistedRuntimeState: (ctx: ExtensionContext) => void;
+}
+export declare function createPersistedRuntimeState(deps: PersistedRuntimeStateDeps): PersistedRuntimeStateManager;

package/dist/persisted-runtime-state.js

@@ -0,0 +1,98 @@
+import * as os from "node:os";
+import { buildPinetOwnerToken, resolveAgentStableId, resolveBrokerStableId, resolvePersistedAgentIdentity, } from "./helpers.js";
+export function createPersistedRuntimeState(deps) {
+    let persistTimer = null;
+    function persistStateNow() {
+        persistTimer = null;
+        try {
+            deps.pi.appendEntry("slack-bridge-state", {
+                threads: Array.from(deps.threads.entries()),
+                lastDmChannel: deps.getLastDmChannel(),
+                userNames: Array.from(deps.userNames.entries()),
+                agentName: deps.getAgentName(),
+                agentEmoji: deps.getAgentEmoji(),
+                agentStableId: deps.getAgentStableId(),
+                brokerStableId: deps.getBrokerStableId(),
+                lastPinetRole: deps.getBrokerRole() === "broker" ? "broker" : "worker",
+                activeSkinTheme: deps.getActiveSkinTheme(),
+                agentPersonality: deps.getAgentPersonality(),
+                agentAliases: [...deps.agentAliases],
+            });
+        }
+        catch (error) {
+            console.error(`[slack-bridge] persistState failed: ${deps.formatError(error)}`);
+        }
+    }
+    function persistState() {
+        if (persistTimer) {
+            clearTimeout(persistTimer);
+        }
+        persistTimer = setTimeout(persistStateNow, 1_000);
+    }
+    function flushPersist() {
+        if (!persistTimer) {
+            return;
+        }
+        clearTimeout(persistTimer);
+        persistStateNow();
+    }
+    function restorePersistedRuntimeState(ctx) {
+        try {
+            let savedState = null;
+            for (const entry of ctx.sessionManager.getEntries()) {
+                if (entry.type === "custom" && entry.customType === "slack-bridge-state") {
+                    savedState = entry.data;
+                }
+            }
+            const restoredRole = savedState?.lastPinetRole === "broker" ? "broker" : "worker";
+            const agentStableId = resolveAgentStableId(savedState?.agentStableId, ctx.sessionManager.getSessionFile(), os.hostname(), ctx.cwd, ctx.sessionManager.getLeafId());
+            const brokerStableId = resolveBrokerStableId(savedState?.brokerStableId, os.hostname(), ctx.cwd);
+            deps.setAgentStableId(agentStableId);
+            deps.setBrokerStableId(brokerStableId);
+            deps.setAgentOwnerToken(buildPinetOwnerToken(restoredRole === "broker" ? brokerStableId : agentStableId));
+            const identitySeed = restoredRole === "broker"
+                ? brokerStableId
+                : (ctx.sessionManager.getSessionFile() ?? agentStableId);
+            deps.setActiveSkinTheme(savedState?.activeSkinTheme ?? null);
+            deps.setAgentPersonality(savedState?.agentPersonality ?? null);
+            deps.agentAliases.clear();
+            for (const alias of savedState?.agentAliases ?? []) {
+                if (alias) {
+                    deps.agentAliases.add(alias);
+                }
+            }
+            const restoredIdentity = resolvePersistedAgentIdentity(deps.getSettings(), savedState?.agentName, savedState?.agentEmoji, process.env.PI_NICKNAME, identitySeed, restoredRole);
+            deps.setAgentName(restoredIdentity.name);
+            deps.setAgentEmoji(restoredIdentity.emoji);
+            if (savedState) {
+                if (savedState.threads) {
+                    for (const [threadTs, info] of savedState.threads) {
+                        if (!deps.threads.has(threadTs)) {
+                            deps.threads.set(threadTs, info);
+                        }
+                    }
+                }
+                if (savedState.lastDmChannel && !deps.getLastDmChannel()) {
+                    deps.setLastDmChannel(savedState.lastDmChannel);
+                }
+                if (savedState.userNames) {
+                    for (const [userId, userName] of savedState.userNames) {
+                        if (!deps.userNames.has(userId)) {
+                            deps.userNames.set(userId, userName);
+                        }
+                    }
+                }
+            }
+            persistStateNow();
+        }
+        catch (error) {
+            console.error(`[slack-bridge] restore failed: ${deps.formatError(error)}`);
+        }
+    }
+    return {
+        persistStateNow,
+        persistState,
+        flushPersist,
+        restorePersistedRuntimeState,
+    };
+}

package/dist/pinet-activity-formatting.d.ts

@@ -0,0 +1,20 @@
+import type { ActivityLogTone } from "./activity-log.js";
+export type PinetTrackedAssignmentStatus = "assigned" | "branch_pushed" | "pr_open" | "pr_merged" | "pr_closed";
+export interface PinetActivityFormattingAgentRecord {
+    emoji: string;
+    name: string;
+}
+export interface PinetActivityFormattingBrokerDbPort {
+    getAgentById: (agentId: string) => PinetActivityFormattingAgentRecord | null;
+}
+export interface PinetActivityFormattingDeps {
+    getActiveBrokerDb: () => PinetActivityFormattingBrokerDbPort | null;
+}
+export interface PinetActivityFormatting {
+    formatTrackedAgent: (agentId: string) => string;
+    summarizeTrackedAssignmentStatus: (status: PinetTrackedAssignmentStatus, prNumber: number | null, branch: string | null) => {
+        summary: string;
+        tone: ActivityLogTone;
+    };
+}
+export declare function createPinetActivityFormatting(deps: PinetActivityFormattingDeps): PinetActivityFormatting;

package/dist/pinet-activity-formatting.js

@@ -0,0 +1,43 @@
+export function createPinetActivityFormatting(deps) {
+    function formatTrackedAgent(agentId) {
+        const agent = deps.getActiveBrokerDb()?.getAgentById(agentId);
+        if (!agent) {
+            return agentId;
+        }
+        return `${agent.emoji} ${agent.name}`.trim();
+    }
+    function summarizeTrackedAssignmentStatus(status, prNumber, branch) {
+        switch (status) {
+            case "pr_merged":
+                return {
+                    summary: `PR #${prNumber ?? "?"} merged`,
+                    tone: "success",
+                };
+            case "pr_open":
+                return {
+                    summary: `PR #${prNumber ?? "?"} opened for review`,
+                    tone: "success",
+                };
+            case "pr_closed":
+                return {
+                    summary: `PR #${prNumber ?? "?"} closed without merge`,
+                    tone: "warning",
+                };
+            case "branch_pushed":
+                return {
+                    summary: `commits pushed on ${branch ?? "tracked branch"}`,
+                    tone: "info",
+                };
+            case "assigned":
+            default:
+                return {
+                    summary: "assigned",
+                    tone: "info",
+                };
+        }
+    }
+    return {
+        formatTrackedAgent,
+        summarizeTrackedAssignmentStatus,
+    };
+}

package/dist/pinet-agent-status.d.ts

@@ -0,0 +1,36 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { SlackBridgeRuntimeMode } from "./runtime-mode.js";
+export type PinetAgentStatusValue = "working" | "idle";
+export interface PinetAgentStatusBrokerDbPort {
+    updateAgentStatus: (agentId: string, status: PinetAgentStatusValue) => void;
+}
+export interface PinetAgentStatusDeps {
+    getPinetEnabled: () => boolean;
+    getBrokerRole: () => "broker" | "follower" | null;
+    getDesiredAgentStatus: () => PinetAgentStatusValue;
+    setDesiredAgentStatus: (status: PinetAgentStatusValue) => void;
+    getActiveBrokerDb: () => PinetAgentStatusBrokerDbPort | null;
+    getActiveBrokerSelfId: () => string | null;
+    hasFollowerClient: () => boolean;
+    syncFollowerDesiredStatus: (status: PinetAgentStatusValue, options: {
+        force?: boolean;
+    }) => Promise<void>;
+    runBrokerMaintenance: (ctx: ExtensionContext) => void;
+    getInboxLength: () => number;
+    getCurrentRuntimeMode: () => SlackBridgeRuntimeMode;
+    maybeDrainInboxIfIdle: (ctx: ExtensionContext) => boolean;
+    getExtensionContext: () => ExtensionContext | undefined;
+}
+export interface PinetAgentStatus {
+    syncDesiredAgentStatus: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    reportStatus: (status: PinetAgentStatusValue) => Promise<void>;
+    signalAgentFree: (ctx?: ExtensionContext, options?: {
+        requirePinet?: boolean;
+    }) => Promise<{
+        queuedInboxCount: number;
+        drainedQueuedInbox: boolean;
+    }>;
+}
+export declare function createPinetAgentStatus(deps: PinetAgentStatusDeps): PinetAgentStatus;

package/dist/pinet-agent-status.js

@@ -0,0 +1,48 @@
+export function createPinetAgentStatus(deps) {
+    async function syncDesiredAgentStatus(options = {}) {
+        if (!deps.getPinetEnabled()) {
+            return;
+        }
+        const desiredAgentStatus = deps.getDesiredAgentStatus();
+        if (deps.getBrokerRole() === "broker") {
+            const db = deps.getActiveBrokerDb();
+            const selfId = deps.getActiveBrokerSelfId();
+            if (!db || !selfId) {
+                return;
+            }
+            db.updateAgentStatus(selfId, desiredAgentStatus);
+            return;
+        }
+        if (deps.getBrokerRole() === "follower" && deps.hasFollowerClient()) {
+            await deps.syncFollowerDesiredStatus(desiredAgentStatus, options);
+        }
+    }
+    async function reportStatus(status) {
+        deps.setDesiredAgentStatus(status);
+        await syncDesiredAgentStatus();
+    }
+    async function signalAgentFree(ctx, options = {}) {
+        const pinetEnabled = deps.getPinetEnabled();
+        if (!pinetEnabled && options.requirePinet) {
+            throw new Error("Pinet is not running. Use /pinet start or /pinet follow first.");
+        }
+        const maintenanceCtx = ctx ?? deps.getExtensionContext() ?? undefined;
+        if (pinetEnabled) {
+            await reportStatus("idle");
+            if (deps.getBrokerRole() === "broker" && maintenanceCtx) {
+                deps.runBrokerMaintenance(maintenanceCtx);
+            }
+        }
+        const queuedInboxCount = deps.getInboxLength();
+        const shouldDrainQueuedInbox = pinetEnabled || deps.getCurrentRuntimeMode() === "single";
+        const drainedQueuedInbox = shouldDrainQueuedInbox && queuedInboxCount > 0 && maintenanceCtx
+            ? deps.maybeDrainInboxIfIdle(maintenanceCtx)
+            : false;
+        return { queuedInboxCount, drainedQueuedInbox };
+    }
+    return {
+        syncDesiredAgentStatus,
+        reportStatus,
+        signalAgentFree,
+    };
+}

package/dist/pinet-commands.d.ts

@@ -0,0 +1,70 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type FollowerRuntimeDiagnostic, type SlackBridgeSettings } from "./helpers.js";
+import { type LoggedActivityLogEntry } from "./activity-log.js";
+import { type SlackScopeDiagnostics } from "./slack-scope-diagnostics.js";
+import type { SlackBridgeRuntimeMode } from "./runtime-mode.js";
+import type { RalphSnoozeStatus } from "./ralph-loop.js";
+export interface PinetCommandsDeps {
+    pinetEnabled: () => boolean;
+    pinetRegistrationBlocked: () => boolean;
+    runtimeMode: () => SlackBridgeRuntimeMode;
+    runtimeConnected: () => boolean;
+    brokerRole: () => "broker" | "follower" | null;
+    agentName: () => string;
+    agentEmoji: () => string;
+    agentOwnerToken: () => string;
+    agentPersonality: () => string | null;
+    agentAliases: () => Set<string>;
+    botUserId: () => string | null;
+    activeSkinTheme: () => string | null;
+    lastDmChannel: () => string | null;
+    followerRuntimeDiagnostic: () => FollowerRuntimeDiagnostic | null;
+    threads: () => Map<string, {
+        owner?: string;
+    }>;
+    allowedUsers: () => Set<string> | null;
+    inboxLength: () => number;
+    recentActivityLogEntries: (limit: number) => ReadonlyArray<LoggedActivityLogEntry>;
+    slackScopeDiagnostics: () => SlackScopeDiagnostics;
+    settings: () => SlackBridgeSettings;
+    lastBrokerMaintenance: () => {
+        pendingBacklogCount: number;
+        assignedBacklogCount: number;
+        reapedAgentIds: string[];
+        repairedThreadClaims: number;
+        anomalies: string[];
+    } | null;
+    ralphSnoozeStatus?: () => RalphSnoozeStatus | null;
+    snoozeRalphLoop?: (input: {
+        durationMs: number;
+        reason?: string | null;
+    }) => RalphSnoozeStatus;
+    clearRalphSnooze?: () => RalphSnoozeStatus;
+    getBrokerControlPlaneHomeTabViewerIds: () => string[];
+    lastBrokerControlPlaneHomeTabRefreshAt: () => string | null;
+    lastBrokerControlPlaneHomeTabError: () => string | null;
+    getPinetRegistrationBlockReason: () => string;
+    connectAsBroker: (ctx: ExtensionContext) => Promise<void>;
+    connectAsFollower: (ctx: ExtensionContext) => Promise<void>;
+    reloadPinetRuntime: (ctx: ExtensionContext) => Promise<void>;
+    disconnectFollower: (ctx: ExtensionContext) => Promise<{
+        unregisterError: string | null;
+    }>;
+    sendPinetAgentMessage: (target: string, body: string) => Promise<{
+        messageId: number;
+        target: string;
+    }>;
+    signalAgentFree: (ctx: ExtensionContext, options: {
+        requirePinet?: boolean;
+    }) => Promise<{
+        queuedInboxCount: number;
+        drainedQueuedInbox: boolean;
+    }>;
+    applyLocalAgentIdentity: (name: string, emoji: string, personality: string | null) => void;
+    setExtStatus: (ctx: ExtensionContext, state: "ok" | "reconnecting" | "error" | "off") => void;
+    setExtCtx: (ctx: ExtensionContext) => void;
+}
+export type PinetCommandAction = "start" | "follow" | "unfollow" | "reload" | "exit" | "free" | "status" | "logs" | "rename" | "snooze";
+export declare function formatPinetCommandHelp(): string;
+export declare function runPinetCommandAction(deps: PinetCommandsDeps, action: PinetCommandAction, args: string, ctx: ExtensionContext, usageCommand?: string): Promise<void>;
+export declare function registerPinetCommands(pi: ExtensionAPI, deps: PinetCommandsDeps): void;