@pinet/slack-bridge 0.1.0

package/dist/pinet-remote-control.js

@@ -0,0 +1,74 @@
+import { finishPinetRemoteControl, queuePinetRemoteControl, } from "./helpers.js";
+function createInitialRemoteControlState() {
+    return {
+        currentCommand: null,
+        queuedCommand: null,
+    };
+}
+export function createPinetRemoteControl(deps) {
+    let remoteControlState = createInitialRemoteControlState();
+    function resetRemoteControlState() {
+        remoteControlState = createInitialRemoteControlState();
+    }
+    function runRemoteControl(command, ctx) {
+        deps.flushDeferredRemoteControlAcks(command);
+        const controlCtx = ctx;
+        if (!(ctx.isIdle?.() ?? true)) {
+            try {
+                controlCtx.abort?.();
+            }
+            catch {
+                /* best effort */
+            }
+        }
+        ctx.ui.notify(`Pinet remote control requested: /${command}`, "warning");
+        void (async () => {
+            try {
+                if (command === "interrupt") {
+                    return;
+                }
+                if (command === "reload") {
+                    await deps.reloadPinetRuntime(ctx);
+                    return;
+                }
+                if (typeof controlCtx.shutdown !== "function") {
+                    throw new Error("Shutdown is not available in this extension context.");
+                }
+                controlCtx.shutdown();
+            }
+            catch (err) {
+                ctx.ui.notify(`Pinet remote control failed: ${deps.formatError(err)}`, "error");
+            }
+            finally {
+                const next = finishPinetRemoteControl(remoteControlState);
+                remoteControlState = {
+                    currentCommand: next.currentCommand,
+                    queuedCommand: next.queuedCommand,
+                };
+                if (next.nextCommand) {
+                    ctx.ui.notify(`Pinet remote control continuing with queued /${next.nextCommand}`, "warning");
+                    runRemoteControl(next.nextCommand, ctx);
+                }
+            }
+        })();
+    }
+    function requestRemoteControl(command, ctx) {
+        const queued = queuePinetRemoteControl(remoteControlState, command);
+        remoteControlState = {
+            currentCommand: queued.currentCommand,
+            queuedCommand: queued.queuedCommand,
+        };
+        if (queued.status === "queued") {
+            ctx.ui.notify(`Pinet remote control queued: /${queued.queuedCommand ?? command}`, "warning");
+        }
+        else if (!queued.shouldStartNow) {
+            ctx.ui.notify(`Pinet remote control already scheduled — keeping /${queued.scheduledCommand}`, "warning");
+        }
+        return queued;
+    }
+    return {
+        requestRemoteControl,
+        runRemoteControl,
+        resetRemoteControlState,
+    };
+}

package/dist/pinet-runtime-composition.d.ts

@@ -0,0 +1,27 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Broker } from "./broker/index.js";
+import type { MessageRouter } from "./broker/router.js";
+import type { InboundMessage, MessageAdapter } from "./broker/types.js";
+export interface PinetRuntimeAdapterBinding {
+    /** Transport adapter to attach to the broker runtime. */
+    adapter: MessageAdapter;
+    /** Optional compatibility status used by Slack bridge startup/status surfaces. */
+    getBotUserId?: () => string | null;
+}
+export interface PinetRuntimeAdapterFactoryContext {
+    broker: Broker;
+    router: MessageRouter;
+    selfId: string;
+    ctx: ExtensionContext;
+}
+export type PinetRuntimeAdapterFactory = (context: PinetRuntimeAdapterFactoryContext) => PinetRuntimeAdapterBinding | PinetRuntimeAdapterBinding[] | Promise<PinetRuntimeAdapterBinding | PinetRuntimeAdapterBinding[]>;
+export interface ConnectPinetRuntimeAdaptersOptions {
+    broker: Pick<Broker, "addAdapter">;
+    bindings: PinetRuntimeAdapterBinding[];
+    onInbound: (message: InboundMessage) => void;
+}
+export interface ConnectPinetRuntimeAdaptersResult {
+    botUserId: string | null;
+}
+export declare function buildPinetRuntimeAdapterBindings(factories: readonly PinetRuntimeAdapterFactory[], context: PinetRuntimeAdapterFactoryContext): Promise<PinetRuntimeAdapterBinding[]>;
+export declare function connectPinetRuntimeAdapters({ broker, bindings, onInbound, }: ConnectPinetRuntimeAdaptersOptions): Promise<ConnectPinetRuntimeAdaptersResult>;

package/dist/pinet-runtime-composition.js

@@ -0,0 +1,20 @@
+function normalizeAdapterBindings(value) {
+    return Array.isArray(value) ? value : [value];
+}
+export async function buildPinetRuntimeAdapterBindings(factories, context) {
+    const bindings = [];
+    for (const factory of factories) {
+        bindings.push(...normalizeAdapterBindings(await factory(context)));
+    }
+    return bindings;
+}
+export async function connectPinetRuntimeAdapters({ broker, bindings, onInbound, }) {
+    let botUserId = null;
+    for (const binding of bindings) {
+        binding.adapter.onInbound(onInbound);
+        broker.addAdapter(binding.adapter);
+        await binding.adapter.connect();
+        botUserId ??= binding.getBotUserId?.() ?? null;
+    }
+    return { botUserId };
+}

package/dist/pinet-tools.d.ts

@@ -0,0 +1,67 @@
+import { type PinetReadOptions, type PinetReadResult } from "@pinet/pinet-core/pinet-read-formatting";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { RalphSnoozeStatus } from "./ralph-loop.js";
+import type { PortLeaseAcquireInput, PortLeaseInfo, PortLeaseListOptions, PortLeaseReleaseInput, PortLeaseRenewInput, PinetLaneInfo, PinetLaneListOptions, PinetLaneParticipantInfo, PinetLaneParticipantUpsertInput, PinetLaneUpsertInput } from "./broker/types.js";
+export interface PinetToolsAgentRecord {
+    emoji: string;
+    name: string;
+    id: string;
+    pid?: number;
+    status: "working" | "idle";
+    metadata: Record<string, unknown> | null;
+    lastHeartbeat: string;
+    lastSeen?: string;
+    disconnectedAt?: string | null;
+    resumableUntil?: string | null;
+    outboundCount?: number;
+    pendingInboxCount?: number;
+}
+export interface RegisterPinetToolsDeps {
+    pinetEnabled: () => boolean;
+    brokerRole: () => "broker" | "follower" | null;
+    requireToolPolicy: (toolName: string, threadTs: string | undefined, action: string) => void;
+    sendPinetAgentMessage: (target: string, body: string, metadata?: Record<string, unknown>) => Promise<{
+        messageId: number;
+        target: string;
+        transferredThreadId?: string;
+        transferredThreadChannel?: string;
+    }>;
+    sendPinetBroadcastMessage: (channel: string, body: string) => {
+        channel: string;
+        messageIds: number[];
+        recipients: string[];
+    };
+    signalAgentFree: (ctx: ExtensionContext | undefined, options: {
+        requirePinet?: boolean;
+    }) => Promise<{
+        queuedInboxCount: number;
+        drainedQueuedInbox: boolean;
+    }>;
+    scheduleBrokerWakeup: (fireAt: string, message: string) => Promise<{
+        id: number;
+        fireAt: string;
+    }>;
+    scheduleFollowerWakeup: (fireAt: string, message: string) => Promise<{
+        id: number;
+        fireAt: string;
+    }>;
+    readPinetInbox: (options: PinetReadOptions) => Promise<PinetReadResult>;
+    listBrokerAgents: () => PinetToolsAgentRecord[];
+    listFollowerAgents: (includeGhosts: boolean) => Promise<PinetToolsAgentRecord[]>;
+    listPinetLanes: (options: PinetLaneListOptions) => Promise<PinetLaneInfo[]>;
+    upsertPinetLane: (input: PinetLaneUpsertInput) => Promise<PinetLaneInfo>;
+    setPinetLaneParticipant: (input: PinetLaneParticipantUpsertInput) => Promise<PinetLaneParticipantInfo>;
+    acquirePortLease: (input: PortLeaseAcquireInput) => Promise<PortLeaseInfo>;
+    renewPortLease: (input: PortLeaseRenewInput) => Promise<PortLeaseInfo>;
+    releasePortLease: (input: PortLeaseReleaseInput) => Promise<PortLeaseInfo>;
+    getPortLease: (leaseId: string) => Promise<PortLeaseInfo | null>;
+    listPortLeases: (options: PortLeaseListOptions) => Promise<PortLeaseInfo[]>;
+    expirePortLeases: () => Promise<PortLeaseInfo[]>;
+    ralphSnoozeStatus?: () => RalphSnoozeStatus | null;
+    snoozeRalphLoop?: (input: {
+        durationMs: number;
+        reason?: string | null;
+    }) => RalphSnoozeStatus;
+    clearRalphSnooze?: () => RalphSnoozeStatus;
+}
+export declare function registerPinetTools(pi: ExtensionAPI, deps: RegisterPinetToolsDeps): void;