@pinet/slack-bridge 0.1.2 → 0.2.0

package/dist/stale-slack-messages.d.ts

@@ -0,0 +1,12 @@
+export declare const STALE_SLACK_MESSAGE_MAX_AGE_MS: number;
+export interface SlackMessageStalenessInput {
+    source: string;
+    timestamp: string;
+}
+export interface SlackMessageStalenessOptions {
+    nowMs?: number;
+    maxAgeMs?: number;
+}
+export declare function parseSlackTimestampMs(timestamp: string): number | null;
+export declare function getSlackMessageAgeMs(input: SlackMessageStalenessInput, options?: SlackMessageStalenessOptions): number | null;
+export declare function isStaleSlackMessage(input: SlackMessageStalenessInput, options?: SlackMessageStalenessOptions): boolean;

package/dist/stale-slack-messages.js

@@ -0,0 +1,29 @@
+export const STALE_SLACK_MESSAGE_MAX_AGE_MS = 15 * 60 * 1000;
+// Slack message ts values are epoch seconds. Treat tiny test/sentinel values as
+// ambiguous rather than stale so only plausible Slack-origin event timestamps
+// are skipped.
+const MIN_PLAUSIBLE_SLACK_TIMESTAMP_SECONDS = 1_000_000_000;
+export function parseSlackTimestampMs(timestamp) {
+    const seconds = Number(timestamp);
+    if (!Number.isFinite(seconds) || seconds < MIN_PLAUSIBLE_SLACK_TIMESTAMP_SECONDS) {
+        return null;
+    }
+    return Math.trunc(seconds * 1000);
+}
+export function getSlackMessageAgeMs(input, options = {}) {
+    if (input.source !== "slack") {
+        return null;
+    }
+    const timestampMs = parseSlackTimestampMs(input.timestamp);
+    if (timestampMs === null) {
+        return null;
+    }
+    return (options.nowMs ?? Date.now()) - timestampMs;
+}
+export function isStaleSlackMessage(input, options = {}) {
+    const ageMs = getSlackMessageAgeMs(input, options);
+    if (ageMs === null) {
+        return false;
+    }
+    return ageMs > (options.maxAgeMs ?? STALE_SLACK_MESSAGE_MAX_AGE_MS);
+}

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

@@ -0,0 +1,109 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { PinetReadOptions, PinetReadResult } from "@pinet/pinet-core/pinet-read-formatting";
+import { type InboxMessage, type PinetControlCommand, type PinetRemoteControlRequestResult, type SlackBridgeSettings } from "./helpers.js";
+export interface SubtreeBrokerPaths {
+    rootDir: string;
+    socketPath: string;
+    dbPath: string;
+    lockPath: string;
+}
+export interface SubtreeWorkerRecord {
+    launchId: string;
+    sessionName: string;
+    repoPath: string;
+    role: string;
+    laneId: string | null;
+    agentId: string | null;
+    startedAt: string;
+    monitorCommand: string;
+}
+export interface SubtreeBrokerStatus {
+    active: boolean;
+    selfAgentId: string | null;
+    startedAt: string | null;
+    paths: SubtreeBrokerPaths | null;
+    childLaunchEnv: Record<string, string>;
+    childLaunchHint: string | null;
+    childCount: number;
+    spawnedWorkers: SubtreeWorkerRecord[];
+}
+export interface SubtreeAgentRecord {
+    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;
+    parentAgentId?: string | null;
+    rootAgentId?: string | null;
+    treeDepth?: number;
+    supervisionState?: string;
+    subtreeRole?: string | null;
+    laneId?: string | null;
+}
+export interface SubtreeSpawnInput {
+    task: string;
+    repo: string;
+    role?: string;
+    laneId?: string;
+    waitForRegistrationMs?: number;
+}
+export interface SubtreeSpawnResult {
+    status: "started";
+    launchId: string;
+    sessionName: string;
+    repoPath: string;
+    role: string;
+    laneId: string | null;
+    agentId: string;
+    agentName: string;
+    messageId: number;
+    threadId: string;
+    monitorCommand: string;
+    socketPath: string;
+    dbPath: string;
+    childLaunchEnv: Record<string, string>;
+}
+export interface SubtreeBrokerRuntimeDeps {
+    cwd: string;
+    getSettings: () => SlackBridgeSettings;
+    getAgentStableId: () => string;
+    getCentralAgentId: () => string | null;
+    getAgentIdentity: () => {
+        name: string;
+        emoji: string;
+    };
+    getAgentMetadata: (role: "broker" | "worker") => Promise<Record<string, unknown>>;
+    getMeshRoleFromMetadata: (metadata: Record<string, unknown> | undefined, fallback?: "broker" | "worker") => "broker" | "worker";
+    pushInboxMessages: (messages: InboxMessage[]) => void;
+    updateBadge: () => void;
+    maybeDrainInboxIfIdle: (ctx: ExtensionContext) => boolean;
+    requestRemoteControl: (command: PinetControlCommand, ctx: ExtensionContext) => PinetRemoteControlRequestResult;
+    runRemoteControl: (command: PinetControlCommand, ctx: ExtensionContext) => void;
+    formatError: (error: unknown) => string;
+}
+export interface SubtreeBrokerRuntime {
+    start: (ctx: ExtensionContext) => Promise<SubtreeBrokerStatus>;
+    stop: (options?: {
+        releaseIdentity?: boolean;
+        stopChildren?: boolean;
+    }) => Promise<void>;
+    getStatus: () => SubtreeBrokerStatus;
+    readInbox: (options?: PinetReadOptions) => PinetReadResult | null;
+    sendMessage: (target: string, body: string, metadata?: Record<string, unknown>) => Promise<{
+        messageId: number;
+        target: string;
+        threadId: string;
+    } | null>;
+    listAgents: (includeGhosts?: boolean) => SubtreeAgentRecord[] | null;
+    spawnWorker: (ctx: ExtensionContext, input: SubtreeSpawnInput) => Promise<SubtreeSpawnResult>;
+    isActive: () => boolean;
+}
+export declare function buildSubtreeBrokerPaths(stableId: string): SubtreeBrokerPaths;
+export declare function createSubtreeBrokerRuntime(deps: SubtreeBrokerRuntimeDeps): SubtreeBrokerRuntime;