@pinet/slack-bridge 0.1.0

package/dist/broker/types.d.ts

@@ -0,0 +1 @@
+export * from "@pinet/broker-core/types";

package/dist/broker/types.js

@@ -0,0 +1 @@
+export * from "@pinet/broker-core/types";

package/dist/broker-delivery.d.ts

@@ -0,0 +1,10 @@
+import type { InboxMessage } from "./helpers.js";
+export interface BrokerDeliveryState {
+    pendingInboxIds: Set<number>;
+}
+export declare function createBrokerDeliveryState(): BrokerDeliveryState;
+export declare function resetBrokerDeliveryState(state: BrokerDeliveryState): void;
+export declare function isBrokerInboxIdTracked(state: BrokerDeliveryState, inboxId: number): boolean;
+export declare function queueBrokerInboxIds(state: BrokerDeliveryState, inboxIds: Iterable<number>): void;
+export declare function markBrokerInboxIdsHandled(state: BrokerDeliveryState, inboxIds: Iterable<number>): void;
+export declare function getBrokerInboxIds(messages: InboxMessage[]): number[];

package/dist/broker-delivery.js

@@ -0,0 +1,26 @@
+export function createBrokerDeliveryState() {
+    return {
+        pendingInboxIds: new Set(),
+    };
+}
+export function resetBrokerDeliveryState(state) {
+    state.pendingInboxIds.clear();
+}
+export function isBrokerInboxIdTracked(state, inboxId) {
+    return state.pendingInboxIds.has(inboxId);
+}
+export function queueBrokerInboxIds(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        state.pendingInboxIds.add(inboxId);
+    }
+}
+export function markBrokerInboxIdsHandled(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        state.pendingInboxIds.delete(inboxId);
+    }
+}
+export function getBrokerInboxIds(messages) {
+    return [
+        ...new Set(messages.flatMap((message) => (message.brokerInboxId ? [message.brokerInboxId] : []))),
+    ];
+}

package/dist/broker-inbound-persistence.d.ts

@@ -0,0 +1,11 @@
+import type { BrokerMessage, DeliveredInboundMessageResult, InboundMessage } from "@pinet/broker-core/types";
+export interface DeliveredInboundPersistenceStore {
+    queueDeliveredMessage(agentId: string, message: InboundMessage): DeliveredInboundMessageResult;
+}
+export interface PersistedInboundNotification {
+    result: DeliveredInboundMessageResult;
+    notificationText: string;
+}
+export declare function buildPinetReadPointer(threadId: string): string;
+export declare function buildPersistedInboundNotificationText(message: BrokerMessage): string;
+export declare function persistDeliveredInboundMessage(store: DeliveredInboundPersistenceStore, agentId: string, message: InboundMessage): PersistedInboundNotification;

package/dist/broker-inbound-persistence.js

@@ -0,0 +1,22 @@
+export function buildPinetReadPointer(threadId) {
+    const trimmed = threadId.trim();
+    const parts = [
+        "pointer=pinet action=read",
+        trimmed ? `args.thread_id=${trimmed}` : null,
+        "args.unread_only=true",
+    ].filter((part) => Boolean(part));
+    return parts.join(" ");
+}
+export function buildPersistedInboundNotificationText(message) {
+    return [
+        `Durable ${message.source} mail stored as #${message.id}.`,
+        buildPinetReadPointer(message.threadId),
+    ].join(" ");
+}
+export function persistDeliveredInboundMessage(store, agentId, message) {
+    const result = store.queueDeliveredMessage(agentId, message);
+    return {
+        result,
+        notificationText: buildPersistedInboundNotificationText(result.message),
+    };
+}

package/dist/broker-prompt-loader.d.ts

@@ -0,0 +1,34 @@
+export declare const DEFAULT_BROKER_PROMPT_MAX_BYTES: number;
+export type BrokerPromptSource = "configured" | "workspace" | "user" | "packaged";
+export interface BrokerPromptWarning {
+    source: BrokerPromptSource;
+    reason: "unsafe_path" | "unreadable" | "too_large" | "invalid_utf8" | "empty";
+    message: string;
+}
+export interface BrokerPromptCandidate {
+    source: BrokerPromptSource;
+    path: string;
+    root: string;
+    required: boolean;
+}
+export interface BrokerPromptLoadOptions {
+    workspaceRoot?: string;
+    cwd?: string;
+    homeDir?: string;
+    defaultPromptPath?: string;
+    configuredPrompt?: string;
+    maxBytes?: number;
+}
+export interface BrokerPromptLoadResult {
+    source: BrokerPromptSource;
+    content: string;
+    warnings: BrokerPromptWarning[];
+    diagnostic: string;
+}
+export interface BrokerPromptTemplateValues {
+    agentEmoji: string;
+    agentName: string;
+}
+export declare function resolveBrokerPromptCandidates(options?: BrokerPromptLoadOptions): BrokerPromptCandidate[];
+export declare function loadBrokerPrompt(options?: BrokerPromptLoadOptions): Promise<BrokerPromptLoadResult>;
+export declare function renderBrokerPromptContent(content: string, values: BrokerPromptTemplateValues): string;

package/dist/broker-prompt-loader.js

@@ -0,0 +1,185 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { TextDecoder } from "node:util";
+import { probeGitContext } from "./git-metadata.js";
+export const DEFAULT_BROKER_PROMPT_MAX_BYTES = 64 * 1024;
+const decoder = new TextDecoder("utf-8", { fatal: true });
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+function isWithinRoot(candidate, root) {
+    return candidate === root || candidate.startsWith(`${root}${path.sep}`);
+}
+function describeSource(source) {
+    switch (source) {
+        case "configured":
+            return "configured prompt";
+        case "workspace":
+            return "workspace override";
+        case "user":
+            return "user-local override";
+        case "packaged":
+            return "packaged default";
+    }
+}
+function warning(source, reason, detail) {
+    return {
+        source,
+        reason,
+        message: `broker prompt: ${describeSource(source)} rejected (${detail}); continuing`,
+    };
+}
+function resolveConfiguredBrokerPromptCandidate(configuredPrompt, options) {
+    const prompt = configuredPrompt?.trim();
+    if (!prompt) {
+        return null;
+    }
+    const hasPathSyntax = prompt.startsWith(".") ||
+        prompt.startsWith("~") ||
+        path.isAbsolute(prompt) ||
+        prompt.includes("/") ||
+        prompt.includes(path.sep);
+    if (!hasPathSyntax) {
+        const presetFile = prompt.endsWith(".md") ? prompt : `${prompt}.md`;
+        const presetPath = path.resolve(moduleDir, "prompts", "broker", presetFile);
+        return {
+            source: "configured",
+            path: presetPath,
+            root: path.resolve(path.dirname(path.dirname(path.dirname(presetPath)))),
+            required: true,
+        };
+    }
+    const expandedPath = prompt.startsWith("~/")
+        ? path.join(options.homeDir, prompt.slice(2))
+        : prompt;
+    const resolvedPath = path.isAbsolute(expandedPath)
+        ? path.resolve(expandedPath)
+        : path.resolve(options.workspaceRoot, expandedPath);
+    return {
+        source: "configured",
+        path: resolvedPath,
+        root: path.isAbsolute(expandedPath) ? path.dirname(resolvedPath) : options.workspaceRoot,
+        required: true,
+    };
+}
+export function resolveBrokerPromptCandidates(options = {}) {
+    const workspaceRoot = path.resolve(options.workspaceRoot ?? options.cwd ?? process.cwd());
+    const homeDir = path.resolve(options.homeDir ?? process.env.HOME ?? "");
+    const userRoot = path.join(homeDir, ".pi", "agent", "slack-bridge");
+    const defaultPromptPath = path.resolve(options.defaultPromptPath ?? path.join(moduleDir, "prompts", "broker", "tmux.md"));
+    const defaultRoot = path.resolve(path.dirname(path.dirname(path.dirname(defaultPromptPath))));
+    const packagedCandidates = [
+        {
+            source: "packaged",
+            path: defaultPromptPath,
+            root: defaultRoot,
+            required: true,
+        },
+    ];
+    const configuredCandidate = resolveConfiguredBrokerPromptCandidate(options.configuredPrompt, {
+        workspaceRoot,
+        homeDir,
+    });
+    return [
+        ...(configuredCandidate ? [configuredCandidate] : []),
+        {
+            source: "workspace",
+            path: path.join(workspaceRoot, ".pi", "slack-bridge", "tmux.md"),
+            root: workspaceRoot,
+            required: false,
+        },
+        {
+            source: "user",
+            path: path.join(userRoot, "tmux.md"),
+            root: userRoot,
+            required: false,
+        },
+        ...packagedCandidates,
+    ];
+}
+async function readValidCandidate(candidate, maxBytes) {
+    let realRoot;
+    let realPath;
+    try {
+        realRoot = await fs.realpath(candidate.root);
+        realPath = await fs.realpath(candidate.path);
+    }
+    catch (error) {
+        if (!candidate.required && error.code === "ENOENT") {
+            return null;
+        }
+        return { warning: warning(candidate.source, "unreadable", "unreadable") };
+    }
+    if (!isWithinRoot(realPath, realRoot)) {
+        return { warning: warning(candidate.source, "unsafe_path", "path escapes allowed root") };
+    }
+    let stat;
+    try {
+        stat = await fs.stat(realPath);
+    }
+    catch {
+        return { warning: warning(candidate.source, "unreadable", "unreadable") };
+    }
+    if (!stat.isFile()) {
+        return { warning: warning(candidate.source, "unreadable", "not a regular file") };
+    }
+    if (stat.size > maxBytes) {
+        return { warning: warning(candidate.source, "too_large", `over ${maxBytes} bytes`) };
+    }
+    let data;
+    try {
+        data = await fs.readFile(realPath);
+    }
+    catch {
+        return { warning: warning(candidate.source, "unreadable", "unreadable") };
+    }
+    let content;
+    try {
+        content = decoder.decode(data);
+    }
+    catch {
+        return { warning: warning(candidate.source, "invalid_utf8", "invalid UTF-8") };
+    }
+    if (content.includes("\0")) {
+        return { warning: warning(candidate.source, "invalid_utf8", "binary-looking content") };
+    }
+    const trimmed = content.trim();
+    if (trimmed.length === 0) {
+        return { warning: warning(candidate.source, "empty", "empty file") };
+    }
+    return { content: trimmed };
+}
+async function resolveDefaultWorkspaceRoot(options) {
+    if (options.workspaceRoot) {
+        return path.resolve(options.workspaceRoot);
+    }
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const gitContext = await probeGitContext(cwd);
+    return path.resolve(gitContext.repoRoot ?? cwd);
+}
+export async function loadBrokerPrompt(options = {}) {
+    const warnings = [];
+    const maxBytes = options.maxBytes ?? DEFAULT_BROKER_PROMPT_MAX_BYTES;
+    const workspaceRoot = await resolveDefaultWorkspaceRoot(options);
+    for (const candidate of resolveBrokerPromptCandidates({ ...options, workspaceRoot })) {
+        const result = await readValidCandidate(candidate, maxBytes);
+        if (result === null) {
+            continue;
+        }
+        if ("warning" in result) {
+            warnings.push(result.warning);
+            continue;
+        }
+        return {
+            source: candidate.source,
+            content: result.content,
+            warnings,
+            diagnostic: `broker prompt: ${describeSource(candidate.source)} loaded`,
+        };
+    }
+    throw new Error("No valid broker prompt candidates found; packaged default is missing or invalid.");
+}
+export function renderBrokerPromptContent(content, values) {
+    return content
+        .replaceAll("{{agentEmoji}}", values.agentEmoji)
+        .replaceAll("{{agentName}}", values.agentName);
+}

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

@@ -0,0 +1,14 @@
+import type { Broker } from "./broker/index.js";
+import type { BrokerDB } from "./broker/schema.js";
+export interface BrokerRuntimeAccessDeps {
+    getBroker: () => Broker | null;
+    getSelfId: () => string | null;
+    getHomeTabViewerIds: () => string[];
+}
+export interface BrokerRuntimeAccess {
+    getActiveBroker: () => Broker | null;
+    getActiveBrokerDb: () => BrokerDB | null;
+    getActiveBrokerSelfId: () => string | null;
+    getBrokerControlPlaneHomeTabViewerIds: () => string[];
+}
+export declare function createBrokerRuntimeAccess(deps: BrokerRuntimeAccessDeps): BrokerRuntimeAccess;

package/dist/broker-runtime-access.js

@@ -0,0 +1,20 @@
+export function createBrokerRuntimeAccess(deps) {
+    function getActiveBroker() {
+        return deps.getBroker();
+    }
+    function getActiveBrokerDb() {
+        return getActiveBroker()?.db ?? null;
+    }
+    function getActiveBrokerSelfId() {
+        return deps.getSelfId();
+    }
+    function getBrokerControlPlaneHomeTabViewerIds() {
+        return deps.getHomeTabViewerIds();
+    }
+    return {
+        getActiveBroker,
+        getActiveBrokerDb,
+        getActiveBrokerSelfId,
+        getBrokerControlPlaneHomeTabViewerIds,
+    };
+}

package/dist/broker-runtime.d.ts

@@ -0,0 +1,100 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type InboxMessage, type PinetControlCommand, type PinetRemoteControlRequestResult, type PinetSkinStatusVocabulary, type SlackBridgeSettings } from "./helpers.js";
+import { type Broker } from "./broker/index.js";
+import { MessageRouter } from "./broker/router.js";
+import { type BrokerMaintenanceResult } from "./broker/maintenance.js";
+import { type BrokerDeliveryState } from "./broker-delivery.js";
+import type { InboundMessage } from "./broker/types.js";
+import { type ActivityLogEntry, type ActivityLogTone, type LoggedActivityLogEntry, type SlackActivityLogger } from "./activity-log.js";
+import type { BrokerControlPlaneDashboardSnapshot } from "./broker/control-plane-dashboard.js";
+import { type RalphSnoozeStatus } from "./ralph-loop.js";
+import { type PinetRuntimeAdapterFactory } from "./pinet-runtime-composition.js";
+export interface BrokerRuntimeConnectResult {
+    botUserId: string | null;
+    recoveredBrokerMessages: number;
+    recoveredTargetedBacklogCount: number;
+    releasedBrokerClaims: number;
+}
+export interface BrokerRuntimeDeps {
+    getSettings: () => SlackBridgeSettings;
+    getAllowedUsers: () => Set<string> | null;
+    getBrokerStableId: () => string;
+    setBrokerStableId: (stableId: string) => void;
+    getActiveSkinTheme: () => string | null;
+    setActiveSkinTheme: (theme: string) => void;
+    setAgentOwnerToken: (ownerToken: string) => void;
+    getAgentMetadata: (role: "broker" | "worker") => Promise<Record<string, unknown>>;
+    applyLocalAgentIdentity: (name: string, emoji: string, personality: string | null) => void;
+    buildSkinMetadata: (metadata: Record<string, unknown> | undefined, personality: string, statusVocabulary?: PinetSkinStatusVocabulary) => Record<string, unknown>;
+    getMeshRoleFromMetadata: (metadata: Record<string, unknown> | undefined, fallback?: "broker" | "worker") => "broker" | "worker";
+    handleInboundMessage: (input: {
+        message: InboundMessage;
+        broker: Broker;
+        router: MessageRouter;
+        selfId: string;
+        ctx: ExtensionContext;
+    }) => Promise<void> | void;
+    pushInboxMessages: (messages: InboxMessage[]) => void;
+    updateBadge: () => void;
+    maybeDrainInboxIfIdle: (ctx: ExtensionContext) => boolean;
+    requestRemoteControl: (command: PinetControlCommand, ctx: ExtensionContext) => PinetRemoteControlRequestResult;
+    deferControlAck: (command: PinetControlCommand, inboxId: number) => void;
+    runRemoteControl: (command: PinetControlCommand, ctx: ExtensionContext) => void;
+    formatError: (error: unknown) => string;
+    deliveryState: BrokerDeliveryState;
+    onMaintenanceResult: (ctx: ExtensionContext, input: {
+        result: BrokerMaintenanceResult;
+        previousSignature: string;
+        signature: string;
+    }) => void;
+    onMaintenanceError: (ctx: ExtensionContext, error: unknown) => void;
+    onScheduledWakeupError: (ctx: ExtensionContext, error: unknown) => void;
+    onAgentStatusChange: (ctx: ExtensionContext, changedAgentId: string, status: "working" | "idle") => void;
+    createActivityLogger: (onError: (error: unknown) => void) => SlackActivityLogger;
+    formatTrackedAgent: (agentId: string) => string;
+    summarizeTrackedAssignmentStatus: (status: "assigned" | "branch_pushed" | "pr_open" | "pr_merged" | "pr_closed", prNumber: number | null, branch: string | null) => {
+        summary: string;
+        tone: ActivityLogTone;
+    };
+    sendMaintenanceMessage: (targetAgentId: string, body: string) => void;
+    trySendFollowUp: (body: string, onDelivered: () => void) => void;
+    refreshHomeTabs: (ctx: ExtensionContext, snapshot: BrokerControlPlaneDashboardSnapshot, refreshedAt: string, userIds?: string[]) => Promise<void>;
+    buildControlPlaneDashboardSnapshot: (input: Record<string, unknown>) => BrokerControlPlaneDashboardSnapshot;
+    buildCurrentDashboardSnapshot: (openedAt?: string) => Promise<BrokerControlPlaneDashboardSnapshot | null>;
+    createAdapterBindings: readonly PinetRuntimeAdapterFactory[];
+}
+export declare function resolveConfiguredBrokerSkinTheme(settings: SlackBridgeSettings): string;
+export interface BrokerRuntime {
+    connect: (ctx: ExtensionContext) => Promise<BrokerRuntimeConnectResult>;
+    disconnect: (options?: {
+        releaseIdentity?: boolean;
+    }) => Promise<void>;
+    claimThread: (threadTs: string, channelId: string, source?: string) => void;
+    runMaintenance: (ctx: ExtensionContext) => void;
+    markDelivered: (inboxIds: number[]) => void;
+    startObservability: (ctx: ExtensionContext) => void;
+    clearFollowUpPending: () => void;
+    logActivity: (entry: ActivityLogEntry) => void;
+    getRecentActivityEntries: (limit?: number) => ReadonlyArray<LoggedActivityLogEntry>;
+    getBroker: () => Broker | null;
+    getSelfId: () => string | null;
+    getLastMaintenance: () => BrokerMaintenanceResult | null;
+    getRalphSnoozeStatus: () => RalphSnoozeStatus;
+    snoozeRalphLoop: (input: {
+        durationMs: number;
+        reason?: string | null;
+    }) => RalphSnoozeStatus;
+    clearRalphSnooze: () => RalphSnoozeStatus;
+    heartbeatTimerActive: () => boolean;
+    maintenanceTimerActive: () => boolean;
+    isConnected: () => boolean;
+    getHomeTabViewerIds: () => string[];
+    getLastHomeTabSnapshot: () => BrokerControlPlaneDashboardSnapshot | null;
+    setLastHomeTabSnapshot: (snapshot: BrokerControlPlaneDashboardSnapshot | null) => void;
+    getLastHomeTabRefreshAt: () => string | null;
+    setLastHomeTabRefreshAt: (value: string | null) => void;
+    getLastHomeTabError: () => string | null;
+    setLastHomeTabError: (value: string | null) => void;
+    publishCurrentHomeTabSafely: (userId: string, ctx: ExtensionContext, openedAt?: string) => Promise<boolean>;
+}
+export declare function createBrokerRuntime(deps: BrokerRuntimeDeps): BrokerRuntime;