@pinet/slack-bridge 0.1.0

package/dist/broker/index.js

@@ -0,0 +1,90 @@
+import * as fs from "node:fs";
+import { BrokerDB } from "./schema.js";
+import { loadOrCreateMeshSecret } from "./auth.js";
+import { BrokerSocketServer } from "./socket-server.js";
+import { assertLoopbackTcpHost } from "./raw-tcp-loopback.js";
+import { LeaderLock } from "./leader.js";
+import { getDefaultSocketPath } from "./paths.js";
+export { BrokerDB } from "./schema.js";
+export { BrokerSocketServer } from "./socket-server.js";
+export { LeaderLock } from "./leader.js";
+/**
+ * Start the broker: acquire leader lock, initialize SQLite, start the Unix socket server.
+ * Only one broker may run at a time — enforced by a PID lock file.
+ *
+ * Throws if another broker process already holds the lock.
+ */
+export async function startBroker(options = {}) {
+    // Resolve listen target: explicit target > socketPath > default
+    const target = options.listenTarget ?? {
+        type: "unix",
+        path: options.socketPath ?? getDefaultSocketPath(),
+    };
+    if (target.type === "tcp") {
+        assertLoopbackTcpHost(target.host, "broker listen target");
+    }
+    // ── Leader lock: prevent split-brain (issue #119) ────
+    const lock = new LeaderLock(options.lockPath);
+    if (!lock.tryAcquire()) {
+        throw new Error("Another pinet broker is already running. Only one broker may be active at a time.");
+    }
+    const db = new BrokerDB(options.dbPath);
+    try {
+        db.initialize();
+    }
+    catch (err) {
+        lock.release();
+        throw err;
+    }
+    // Clean up stale socket file (Unix only)
+    if (target.type === "unix") {
+        try {
+            const stat = fs.statSync(target.path);
+            if (stat.isSocket())
+                fs.unlinkSync(target.path);
+        }
+        catch {
+            /* doesn't exist — fine */
+        }
+    }
+    const meshSecret = options.meshSecret?.trim() || null;
+    const meshSecretPath = options.meshSecretPath?.trim() || null;
+    const resolvedMeshSecret = meshSecret || (meshSecretPath ? loadOrCreateMeshSecret(meshSecretPath) : null);
+    const server = new BrokerSocketServer(db, target, {
+        ...(resolvedMeshSecret ? { meshSecret: resolvedMeshSecret } : {}),
+    });
+    try {
+        await server.start();
+    }
+    catch (err) {
+        db.close();
+        lock.release();
+        throw err;
+    }
+    const adapters = [];
+    const broker = {
+        db,
+        server,
+        lock,
+        adapters,
+        addAdapter(adapter) {
+            adapters.push(adapter);
+            server.setOutboundMessageAdapters(adapters);
+        },
+        async stop() {
+            for (const adapter of adapters) {
+                try {
+                    await adapter.disconnect();
+                }
+                catch {
+                    // best effort
+                }
+            }
+            adapters.length = 0;
+            await server.stop();
+            db.close();
+            lock.release();
+        },
+    };
+    return broker;
+}

package/dist/broker/leader.d.ts

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

package/dist/broker/leader.js

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

package/dist/broker/maintenance.d.ts

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

package/dist/broker/maintenance.js

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

package/dist/broker/message-send.d.ts

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

package/dist/broker/message-send.js

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

package/dist/broker/paths.d.ts

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

package/dist/broker/paths.js

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

package/dist/broker/raw-tcp-loopback.d.ts

@@ -0,0 +1 @@
+export * from "@pinet/broker-core/raw-tcp-loopback";

package/dist/broker/raw-tcp-loopback.js

@@ -0,0 +1 @@
+export * from "@pinet/broker-core/raw-tcp-loopback";

package/dist/broker/router.d.ts

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

package/dist/broker/router.js

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

package/dist/broker/schema.d.ts

@@ -0,0 +1,9 @@
+import { BrokerDB as CoreBrokerDB, CURRENT_BROKER_SCHEMA_VERSION, DEFAULT_DISCONNECTED_PURGE_GRACE_MS, DEFAULT_RESUMABLE_WINDOW_MS, defaultDbPath, type TaskAssignmentAwaitingReplyInfo } from "@pinet/broker-core/schema";
+import type { RalphCycleRecord } from "../helpers.js";
+export { CURRENT_BROKER_SCHEMA_VERSION, DEFAULT_DISCONNECTED_PURGE_GRACE_MS, DEFAULT_RESUMABLE_WINDOW_MS, defaultDbPath, };
+export type { TaskAssignmentAwaitingReplyInfo };
+export declare class BrokerDB extends CoreBrokerDB {
+    initialize(): void;
+    recordRalphCycle(record: Omit<RalphCycleRecord, "id">): number;
+    getRecentRalphCycles(limit?: number): RalphCycleRecord[];
+}

package/dist/broker/schema.js

@@ -0,0 +1,63 @@
+import { BrokerDB as CoreBrokerDB, CURRENT_BROKER_SCHEMA_VERSION, DEFAULT_DISCONNECTED_PURGE_GRACE_MS, DEFAULT_RESUMABLE_WINDOW_MS, defaultDbPath, } from "@pinet/broker-core/schema";
+function ensureRalphCycleTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS ralph_cycles (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      started_at TEXT NOT NULL,
+      completed_at TEXT,
+      duration_ms INTEGER,
+      ghost_agent_ids TEXT NOT NULL DEFAULT '[]',
+      nudge_agent_ids TEXT NOT NULL DEFAULT '[]',
+      idle_drain_agent_ids TEXT NOT NULL DEFAULT '[]',
+      stuck_agent_ids TEXT NOT NULL DEFAULT '[]',
+      anomalies TEXT NOT NULL DEFAULT '[]',
+      anomaly_signature TEXT NOT NULL DEFAULT '',
+      follow_up_delivered INTEGER NOT NULL DEFAULT 0,
+      agent_count INTEGER NOT NULL DEFAULT 0,
+      backlog_count INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_ralph_cycles_started
+      ON ralph_cycles(started_at);
+  `);
+}
+export { CURRENT_BROKER_SCHEMA_VERSION, DEFAULT_DISCONNECTED_PURGE_GRACE_MS, DEFAULT_RESUMABLE_WINDOW_MS, defaultDbPath, };
+export class BrokerDB extends CoreBrokerDB {
+    initialize() {
+        super.initialize();
+        ensureRalphCycleTable(this.getDb());
+    }
+    recordRalphCycle(record) {
+        const db = this.getDb();
+        const info = db
+            .prepare(`INSERT INTO ralph_cycles (
+           started_at, completed_at, duration_ms,
+           ghost_agent_ids, nudge_agent_ids, idle_drain_agent_ids, stuck_agent_ids,
+           anomalies, anomaly_signature, follow_up_delivered,
+           agent_count, backlog_count
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(record.startedAt, record.completedAt, record.durationMs, JSON.stringify(record.ghostAgentIds), JSON.stringify(record.nudgeAgentIds), JSON.stringify(record.idleDrainAgentIds), JSON.stringify(record.stuckAgentIds), JSON.stringify(record.anomalies), record.anomalySignature, record.followUpDelivered ? 1 : 0, record.agentCount, record.backlogCount);
+        return Number(info.lastInsertRowid);
+    }
+    getRecentRalphCycles(limit = 20) {
+        const db = this.getDb();
+        const rows = db
+            .prepare("SELECT * FROM ralph_cycles ORDER BY started_at DESC LIMIT ?")
+            .all(limit);
+        return rows.map((row) => ({
+            id: row.id,
+            startedAt: row.started_at,
+            completedAt: row.completed_at,
+            durationMs: row.duration_ms,
+            ghostAgentIds: JSON.parse(row.ghost_agent_ids),
+            nudgeAgentIds: JSON.parse(row.nudge_agent_ids),
+            idleDrainAgentIds: JSON.parse(row.idle_drain_agent_ids),
+            stuckAgentIds: JSON.parse(row.stuck_agent_ids),
+            anomalies: JSON.parse(row.anomalies),
+            anomalySignature: row.anomaly_signature,
+            followUpDelivered: row.follow_up_delivered === 1,
+            agentCount: row.agent_count,
+            backlogCount: row.backlog_count,
+        }));
+    }
+}

package/dist/broker/socket-server.d.ts

@@ -0,0 +1,120 @@
+import type { BrokerDB } from "./schema.js";
+import type { BrokerMessage, MessageAdapter } from "./types.js";
+export declare const DEFAULT_HEARTBEAT_TIMEOUT_MS = 15000;
+export declare const DEFAULT_PRUNE_INTERVAL_MS = 5000;
+export declare const DEFAULT_AUTH_TIMEOUT_MS = 2000;
+export type ListenTarget = {
+    type: "unix";
+    path: string;
+} | {
+    type: "tcp";
+    host: string;
+    port: number;
+};
+export type AgentMessageCallback = (targetAgentId: string, msg: BrokerMessage, metadata: Record<string, unknown>) => void;
+export type AgentStatusChangeCallback = (agentId: string, status: "working" | "idle") => void;
+export type AgentRegistrationResolver = (input: {
+    agentId: string;
+    name: string;
+    emoji: string;
+    pid: number;
+    stableId?: string;
+    metadata?: Record<string, unknown>;
+}) => {
+    name: string;
+    emoji: string;
+    metadata?: Record<string, unknown>;
+} | null;
+export interface BrokerSocketServerOptions {
+    heartbeatTimeoutMs?: number;
+    pruneIntervalMs?: number;
+    authTimeoutMs?: number;
+    meshSecret?: string;
+}
+export declare class BrokerSocketServer {
+    private server;
+    private readonly target;
+    private readonly db;
+    private readonly router;
+    private readonly connections;
+    private readonly heartbeatTimeoutMs;
+    private readonly pruneIntervalMs;
+    private readonly authTimeoutMs;
+    private readonly meshSecret;
+    private pruneTimer;
+    private assignedPort;
+    private agentMessageCallback;
+    private agentStatusChangeCallback;
+    private outboundMessageAdapters;
+    private agentRegistrationResolver;
+    constructor(db: BrokerDB, target?: ListenTarget | string, options?: BrokerSocketServerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Get connection info for clients. Returns the socket path (Unix)
+     * or { host, port } (TCP).
+     */
+    getConnectInfo(): {
+        type: "unix";
+        path: string;
+    } | {
+        type: "tcp";
+        host: string;
+        port: number;
+    };
+    /**
+     * Register a callback invoked whenever a worker sends an agent-to-agent
+     * message via the socket server. The broker uses this to push messages
+     * targeting itself into its in-memory inbox.
+     */
+    onAgentMessage(cb: AgentMessageCallback): void;
+    /**
+     * Register a callback invoked whenever a connected agent explicitly updates
+     * its broker status. The broker uses idle transitions to kick maintenance so
+     * backlog can be reassigned immediately.
+     */
+    onAgentStatusChange(cb: AgentStatusChangeCallback): void;
+    setAgentRegistrationResolver(resolver: AgentRegistrationResolver | null): void;
+    setOutboundMessageAdapters(adapters: ReadonlyArray<Pick<MessageAdapter, "name" | "send" | "invokeCapability">>): void;
+    private startPruning;
+    private stopPruning;
+    private clearAuthTimer;
+    private startAuthTimer;
+    private disconnectDuplicateConnections;
+    private findLiveStableIdConflict;
+    private onConnection;
+    private processBuffer;
+    private dispatchRequest;
+    private send;
+    private handleRequest;
+    private handleAuth;
+    private handleRegister;
+    private handleUnregister;
+    private handleHeartbeat;
+    private handleInboxPoll;
+    private handleInboxRead;
+    private handleInboxAck;
+    private handleSend;
+    private handleMessageSend;
+    private handleThreadsList;
+    private handleAgentsList;
+    private handleThreadClaim;
+    private handleResolveThread;
+    private handleAgentMessage;
+    private handleAgentBroadcast;
+    private handleLaneList;
+    private handleLaneUpsert;
+    private handleLaneParticipant;
+    private handlePortLeaseAcquire;
+    private handlePortLeaseRenew;
+    private handlePortLeaseRelease;
+    private handlePortLeaseStatus;
+    private handlePortLeaseList;
+    private handlePortLeaseExpire;
+    private handleScheduleCreate;
+    private handleStatusUpdate;
+    private handleAdapterCapability;
+    private handleLegacySlackProxy;
+    private dispatchAdapterCapability;
+    private applyAdapterCapabilityEffects;
+}