@fdcn/sourcefed 0.3.6 → 0.3.8

package/dist.dts/adapters/opencode/bridge.d.ts

@@ -1,34 +1,80 @@
+import { type QueuedMonitorEvent } from "@fdcn/sourcefed/core";
 import { type Plugin } from "@opencode/plugin";
+import { OpenCodeSubscriptions, type SessionLocation } from "./subscriptions.js";
 type SessionDomain = Plugin.Context["session"];
-type RpcDomain = Plugin.Context["rpc"];
+type RpcDomain = (definition: typeof ChauffeurGate) => {
+    gate(input: unknown, options: {
+        signal: AbortSignal;
+    }): Promise<unknown>;
+};
+/**
+ * Chauffeur's gate, declared here so sourcefed does not depend on Chauffeur.
+ * When the Chauffeur plugin runs in this OpenCode process, it decides which
+ * events reach the session; otherwise every event is delivered.
+ */
+declare const ChauffeurGate: {
+    readonly id: "chauffeur";
+    readonly methods: {
+        readonly gate: {
+            readonly input: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly sessionID: {
+                        readonly type: "string";
+                    };
+                    readonly monitorID: {
+                        readonly type: "string";
+                    };
+                    readonly source: {
+                        readonly type: "string";
+                    };
+                    readonly kind: {
+                        readonly type: "string";
+                    };
+                    readonly summary: {
+                        readonly type: "string";
+                    };
+                    readonly body: {
+                        readonly type: "string";
+                    };
+                    readonly actionable: {
+                        readonly type: "boolean";
+                    };
+                };
+                readonly required: readonly ["sessionID", "source", "kind", "summary", "actionable"];
+            };
+            readonly output: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly deliver: {
+                        readonly type: "boolean";
+                    };
+                };
+                readonly required: readonly ["deliver"];
+            };
+        };
+    };
+    readonly events: {};
+};
 export declare class OpenCodeBridge {
     private readonly session;
-    private readonly rpc?;
-    private daemon?;
-    private readonly listeners;
-    private lastAttemptAt;
-    private lastError;
-    private timer;
-    constructor(session: SessionDomain, rpc?: RpcDomain | undefined);
+    private readonly rpc;
+    readonly location: SessionLocation;
+    private readonly hub;
+    private started;
+    private closed;
+    private closing;
+    constructor(session: Pick<SessionDomain, "get" | "synthetic">, rpc: RpcDomain | undefined, location: SessionLocation, hub?: OpenCodeSubscriptions);
     /**
      * Chauffeur or the CLI can create a monitor for a session here at any time,
      * without this bridge's tools, so check for new targets periodically too.
      */
     start(): Promise<void>;
-    ensureTarget(sessionID: string): Promise<void>;
     callTool(name: string, arguments_: Record<string, unknown>, sessionID: string): Promise<unknown>;
     close(): Promise<void>;
-    private refresh;
-    private ensureDaemon;
-    /**
-     * Monitors outlive this process, so after a restart nothing listens for their
-     * sessions until something subscribes. Subscribe every session that has an
-     * enabled monitor and still exists here; a deleted session is skipped, since
-     * delivering to it would fail and retry forever.
-     */
-    private resubscribe;
-    private resubscribeTarget;
-    private routeEvents;
+    refresh(): Promise<void>;
+    getSession(sessionID: string, signal: AbortSignal): Promise<import("@opencode/client").SessionInfo>;
+    routeEvents(events: QueuedMonitorEvent[]): Promise<void>;
     /**
      * Ask Chauffeur's gate, when it runs in this process. Only an explicit
      * `deliver: false` withholds the event; no gate, an error, or a slow answer
@@ -37,6 +83,4 @@ export declare class OpenCodeBridge {
     private admitted;
     private target;
 }
-export declare function setOpenCodeBridge(bridge: OpenCodeBridge): void;
-export declare function getOpenCodeBridge(): OpenCodeBridge;
 export {};

package/dist.dts/adapters/opencode/subscriptions.d.ts

@@ -0,0 +1,46 @@
+import type { QueuedMonitorEvent } from "@fdcn/sourcefed/core";
+import type { DaemonClient } from "@fdcn/sourcefed/daemon";
+export type SessionLocation = {
+    directory: string;
+    project: {
+        id: string;
+    };
+};
+type SessionInfo = {
+    projectID: string;
+    location: {
+        directory: string;
+    };
+};
+export interface SubscriptionOwner {
+    readonly location: SessionLocation;
+    getSession(sessionID: string, signal: AbortSignal): Promise<SessionInfo>;
+    routeEvents(events: QueuedMonitorEvent[]): Promise<void>;
+}
+/** One client, timer and stream per enabled session, shared by all plugin locations. */
+export declare class OpenCodeSubscriptions {
+    private readonly connect;
+    private readonly owners;
+    private readonly subscriptions;
+    private readonly lifetime;
+    private daemon;
+    private connecting;
+    private refreshing;
+    private dirty;
+    private lastAttemptAt;
+    private timer;
+    constructor(connect: () => Promise<DaemonClient>);
+    get closed(): boolean;
+    add(owner: SubscriptionOwner): Promise<void>;
+    remove(owner: SubscriptionOwner): Promise<void>;
+    request(method: string, params: Record<string, unknown>): Promise<unknown>;
+    refresh(): Promise<void>;
+    private refreshLoop;
+    private ensureDaemon;
+    private reconcile;
+    private ownerFor;
+    private subscribe;
+    private route;
+    private closeSubscription;
+}
+export {};

package/dist.dts/adapters/opencode/tool-result.d.ts

@@ -1 +1,2 @@
-export declare function callMonitorTool(name: string, arguments_: Record<string, unknown>, sessionID: string): Promise<string>;
+import type { OpenCodeBridge } from "./bridge.js";
+export declare function callMonitorTool(bridge: OpenCodeBridge, name: string, arguments_: Record<string, unknown>, sessionID: string): Promise<string>;

package/dist.dts/adapters/opencode/tools/monitor_create.d.ts

@@ -1,5 +1,6 @@
 import type { ToolContext } from "@opencode/plugin/promise/tool";
-declare const definition: {
+import type { OpenCodeBridge } from "../bridge.js";
+declare const _default: (bridge: OpenCodeBridge) => {
     name: string;
     description: string;
     input: {
@@ -38,6 +39,22 @@ declare const definition: {
                 type: string;
                 description: string;
             };
+            url: {
+                type: string;
+                description: string;
+            };
+            space: {
+                type: string;
+                description: string;
+            };
+            match: {
+                type: string;
+                description: string;
+            };
+            exclude: {
+                type: string;
+                description: string;
+            };
             pollIntervalSec: {
                 type: string;
                 description: string;
@@ -50,4 +67,4 @@ declare const definition: {
         content: string;
     }>;
 };
-export default definition;
+export default _default;

package/dist.dts/adapters/opencode/tools/monitor_list.d.ts

@@ -1,5 +1,6 @@
 import type { ToolContext } from "@opencode/plugin/promise/tool";
-declare const definition: {
+import type { OpenCodeBridge } from "../bridge.js";
+declare const _default: (bridge: OpenCodeBridge) => {
     name: string;
     description: string;
     input: {
@@ -11,4 +12,4 @@ declare const definition: {
         content: string;
     }>;
 };
-export default definition;
+export default _default;

package/dist.dts/adapters/opencode/tools/monitor_start.d.ts

@@ -1,5 +1,6 @@
 import type { ToolContext } from "@opencode/plugin/promise/tool";
-declare const definition: {
+import type { OpenCodeBridge } from "../bridge.js";
+declare const _default: (bridge: OpenCodeBridge) => {
     name: string;
     description: string;
     input: {
@@ -17,4 +18,4 @@ declare const definition: {
         content: string;
     }>;
 };
-export default definition;
+export default _default;

package/dist.dts/adapters/opencode/tools/monitor_status.d.ts

@@ -1,5 +1,6 @@
 import type { ToolContext } from "@opencode/plugin/promise/tool";
-declare const definition: {
+import type { OpenCodeBridge } from "../bridge.js";
+declare const _default: (bridge: OpenCodeBridge) => {
     name: string;
     description: string;
     input: {
@@ -17,4 +18,4 @@ declare const definition: {
         content: string;
     }>;
 };
-export default definition;
+export default _default;

package/dist.dts/adapters/opencode/tools/monitor_stop.d.ts

@@ -1,5 +1,6 @@
 import type { ToolContext } from "@opencode/plugin/promise/tool";
-declare const definition: {
+import type { OpenCodeBridge } from "../bridge.js";
+declare const _default: (bridge: OpenCodeBridge) => {
     name: string;
     description: string;
     input: {
@@ -17,4 +18,4 @@ declare const definition: {
         content: string;
     }>;
 };
-export default definition;
+export default _default;

package/dist.dts/adapters/pi/src/dialog.d.ts

@@ -1,12 +1,11 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { Component, TUI } from "@earendil-works/pi-tui";
-import type { LogEntryView, MonitorView } from "@fdcn/sourcefed/daemon";
+import type { LogEntryView } from "@fdcn/sourcefed/daemon";
 type Line = {
     text: string;
 };
 export declare function showSourcefedDialog(_tui: TUI, theme: Theme, done: (result: null) => void, title: string, lines: Line[]): Component & {
     handleInput(data: string): void;
 };
-export declare function monitorLines(monitors: MonitorView[], theme: Theme): Line[];
 export declare function logLines(logs: LogEntryView[], theme: Theme): Line[];
 export {};

package/dist.dts/adapters/pi/src/monitors-dialog.d.ts

@@ -0,0 +1,32 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Component, KeybindingsManager } from "@earendil-works/pi-tui";
+import type { MonitorView } from "@fdcn/sourcefed/daemon";
+export type MonitorAction = "stop" | "start" | "remove";
+/** Runs one action on a monitor and answers the target's monitors afterwards. */
+export type RunMonitorAction = (action: MonitorAction, id: string) => Promise<MonitorView[]>;
+export type MonitorManagerDeps = {
+    theme: Pick<Theme, "fg" | "bold">;
+    keys: Pick<KeybindingsManager, "matches">;
+    run: RunMonitorAction;
+    requestRender: () => void;
+    close: () => void;
+};
+export declare class MonitorManager implements Component {
+    private readonly deps;
+    private monitors;
+    private selected;
+    private mode;
+    private error;
+    constructor(monitors: MonitorView[], deps: MonitorManagerDeps);
+    handleInput(data: string): void;
+    render(width: number): string[];
+    invalidate(): void;
+    private handleBrowse;
+    private handleConfirm;
+    private perform;
+    private select;
+    private setMode;
+    private matches;
+    private listLines;
+    private statusLines;
+}

package/dist.dts/packages/core/src/types/monitor-create-input.d.ts

@@ -5,4 +5,8 @@ export type MonitorCreateInput = {
     channelId?: string;
     threadTs?: string;
     threadUrl?: string;
+    url?: string;
+    space?: string;
+    match?: string;
+    exclude?: string;
 };

package/dist.dts/packages/daemon/src/event-stream.d.ts

@@ -0,0 +1,26 @@
+import type { QueuedMonitorEvent } from "@fdcn/sourcefed/core";
+/** Owns one SSE connection, its setup, serialized delivery and reconnect loop. */
+export declare class DaemonEventStream {
+    private readonly url;
+    private readonly headers;
+    private readonly onEvents;
+    private readonly acknowledge;
+    private readonly onClose;
+    private readonly controller;
+    private readonly subscribed;
+    private stream;
+    private delivering;
+    private closing;
+    private ready;
+    private failedDelivery;
+    constructor(url: string, headers: Record<string, string>, onEvents: (events: QueuedMonitorEvent[]) => Promise<void>, acknowledge: (events: QueuedMonitorEvent[], signal: AbortSignal) => Promise<void>, onClose: () => void);
+    start(signal?: AbortSignal): Promise<void>;
+    close(): Promise<void>;
+    private drain;
+    private run;
+    private read;
+    private frame;
+    private deliver;
+    private waitForDelivery;
+}
+export declare function pause(ms: number, signal: AbortSignal): Promise<void>;

package/dist.dts/packages/daemon/src/registry.d.ts

@@ -2,10 +2,12 @@ import type { Monitor, MonitorCreateInput, MonitorSource, SourceInput } from "@f
 import { GithubMonitor } from "@fdcn/sourcefed/provider-github";
 import { JiraMonitor } from "@fdcn/sourcefed/provider-jira";
 import { SlackMonitor } from "@fdcn/sourcefed/provider-slack";
+import { YabMonitor } from "@fdcn/sourcefed/provider-yab";
 export declare const SOURCE_MAP: {
     jira: JiraMonitor;
     github: GithubMonitor;
     slack: SlackMonitor;
+    yab: YabMonitor;
 };
 export declare const SOURCE_TYPES: [string, ...string[]];
 export declare function sourceDefinition(source: MonitorSource): Monitor<any>;

package/dist.dts/packages/daemon/src/stream-lifecycle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist.dts/packages/daemon/src/types/client.d.ts

@@ -10,7 +10,9 @@ export type DaemonClientOptions = {
 };
 export interface DaemonClient {
     request(method: string, params?: Record<string, unknown>): Promise<unknown>;
-    subscribe(target: MonitorTarget, onEvents: (events: QueuedMonitorEvent[]) => Promise<void>): Promise<{
+    subscribe(target: MonitorTarget, onEvents: (events: QueuedMonitorEvent[]) => Promise<void>, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
         close(): Promise<void>;
     }>;
     close(): Promise<void>;

package/dist.dts/packages/daemon/src/types/daemon.d.ts

@@ -8,6 +8,10 @@ export type DaemonCreateInput = {
     channelId?: string;
     threadTs?: string;
     threadUrl?: string;
+    url?: string;
+    space?: string;
+    match?: string;
+    exclude?: string;
     pollIntervalSec?: number;
 };
 export type SourcefedDaemonOptions = {

package/dist.dts/packages/daemon/src/utils/index.d.ts

@@ -1,6 +1,5 @@
 export { daemonEnvironment } from "./env.js";
 export { serveHttp, type HttpServer, type HttpServerOptions } from "./http-server.js";
-export { RequestRouter } from "./request-router.js";
 export { DEFAULT_DAEMON_URL, daemonCommand, defaultDaemonUrl, sleep, spawnLocalDaemon, withTimeout } from "./spawn.js";
 export { NotifyingEventSink } from "./sink.js";
 export { decodeTarget, encodeTarget, targetKey } from "./target.js";

package/dist.dts/providers/yab/src/index.d.ts

@@ -0,0 +1,2 @@
+export { YabMonitor } from "./monitor.js";
+export type { YabSourceRecord, YabEvent, YabCursor, FeedEntry } from "./types";

package/dist.dts/providers/yab/src/monitor.d.ts

@@ -0,0 +1,14 @@
+import { Monitor } from "@fdcn/sourcefed/core";
+import type { MonitorCreateInput } from "@fdcn/sourcefed/core";
+import type { YabSourceRecord } from "./types";
+import type { SourceInput } from "@fdcn/sourcefed/core";
+export declare class YabMonitor extends Monitor<YabSourceRecord> {
+    readonly poll: import("@fdcn/sourcefed/core").PollMonitor<YabSourceRecord>;
+    constructor();
+    readonly key: (source: YabSourceRecord) => string;
+    readonly icon = "\uDB81\uDD9F";
+    readonly label: (source: YabSourceRecord) => string;
+    readonly detail: (source: YabSourceRecord) => string;
+    readonly describe: (source: YabSourceRecord) => string;
+    build(input: MonitorCreateInput): SourceInput;
+}

package/dist.dts/providers/yab/src/poll/index.d.ts

@@ -0,0 +1,2 @@
+export { yabPollMonitor } from "./monitor.js";
+export * from "./utils";

package/dist.dts/providers/yab/src/poll/monitor.d.ts

@@ -0,0 +1,3 @@
+import { PollMonitor } from "@fdcn/sourcefed/core";
+import type { YabSourceRecord } from "../types";
+export declare const yabPollMonitor: PollMonitor<YabSourceRecord>;

package/dist.dts/providers/yab/src/poll/utils/feed-events.d.ts

@@ -0,0 +1,5 @@
+import type { FeedEntry, YabCursor, YabEvent, YabSourceRecord } from "../../types";
+export declare function feedEvents(source: YabSourceRecord, entries: FeedEntry[], cursorRaw: unknown): {
+    events: YabEvent[];
+    cursor: YabCursor;
+};

package/dist.dts/providers/yab/src/poll/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { feedEvents } from "./feed-events.js";
+export { parseFeed } from "./parse-feed.js";
+export { pollYab, type YabFetcher } from "./poll-yab.js";
+export { callYabTool, fetchThroughYab, parseYabFetch } from "./yab-mcp.js";

package/dist.dts/providers/yab/src/poll/utils/parse-feed.d.ts

@@ -0,0 +1,3 @@
+import type { FeedEntry } from "../../types";
+/** Entries of an Atom, RSS or JSON feed, in the order the feed lists them. */
+export declare function parseFeed(body: string, type?: string): FeedEntry[];

package/dist.dts/providers/yab/src/poll/utils/poll-yab.d.ts

@@ -0,0 +1,7 @@
+import type { YabCursor, YabEvent, YabPage, YabSourceRecord } from "../../types";
+export type YabFetcher = (url: string, space?: string) => Promise<YabPage>;
+export declare function pollYab(source: YabSourceRecord, cursorRaw: unknown, fetchPage?: YabFetcher): Promise<{
+    events: YabEvent[];
+    cursor: YabCursor;
+    terminal: false;
+}>;

package/dist.dts/providers/yab/src/poll/utils/yab-mcp.d.ts

@@ -0,0 +1,10 @@
+import type { YabPage } from "../../types";
+/** Read a URL through Yab, with the cookies of the given space (or wherever the site is signed in). */
+export declare function fetchThroughYab(url: string, space?: string): Promise<YabPage>;
+/** Yab's fetch answers `STATUS · TYPE · URL`, a blank line, then the body. */
+export declare function parseYabFetch(text: string): YabPage;
+/**
+ * Call one tool on Yab's MCP server over stdio: `yab mcp` is started for the call and
+ * stopped after it, so nothing stays connected between polls.
+ */
+export declare function callYabTool(name: string, args: Record<string, unknown>): Promise<string>;

package/dist.dts/providers/yab/src/schema.d.ts

@@ -0,0 +1,12 @@
+import * as v from "valibot";
+export declare const YabSourceSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"yab", undefined>;
+    readonly url: v.StringSchema<undefined>;
+    readonly space: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly match: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly exclude: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export declare const YabCursorSchema: v.ObjectSchema<{
+    readonly primed: v.BooleanSchema<undefined>;
+    readonly seenIds: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;

package/dist.dts/providers/yab/src/types/cursor.d.ts

@@ -0,0 +1,4 @@
+export interface YabCursor {
+    primed: boolean;
+    seenIds: string[];
+}

package/dist.dts/providers/yab/src/types/event.d.ts

@@ -0,0 +1,8 @@
+export interface YabEvent {
+    kind: "entry";
+    id: string;
+    at: string;
+    summary: string;
+    body?: string;
+    actionable: boolean;
+}

package/dist.dts/providers/yab/src/types/feed-entry.d.ts

@@ -0,0 +1,8 @@
+export interface FeedEntry {
+    id: string;
+    title: string;
+    summary?: string;
+    author?: string;
+    link?: string;
+    at?: string;
+}

package/dist.dts/providers/yab/src/types/index.d.ts

@@ -0,0 +1,5 @@
+export type { YabCursor } from "./cursor.js";
+export type { YabEvent } from "./event.js";
+export type { FeedEntry } from "./feed-entry.js";
+export type { YabPage } from "./page.js";
+export type { YabSourceRecord } from "./source-record.js";

package/dist.dts/providers/yab/src/types/page.d.ts

@@ -0,0 +1,6 @@
+export interface YabPage {
+    status: number;
+    type: string;
+    url: string;
+    body: string;
+}

package/dist.dts/providers/yab/src/types/source-record.d.ts

@@ -0,0 +1,7 @@
+export type YabSourceRecord = {
+    type: "yab";
+    url: string;
+    space?: string;
+    match?: string;
+    exclude?: string;
+};

package/dist.dts/providers/yab/src/yab.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fdcn/sourcefed",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Live Jira, GitHub, and Slack monitoring for agent hosts: CLI, daemon, MCP server, and host plugins.",
   "license": "MIT",
   "type": "module",

package/dist.dts/packages/daemon/src/utils/forward.d.ts

@@ -1,32 +0,0 @@
-import type { MonitorEvent, MonitorEventSink, MonitorRecord } from "@fdcn/sourcefed/core";
-export type ForwardOptions = {
-    url: string;
-    token?: string;
-    fetch?: typeof fetch;
-};
-/** The JSON body POSTed for each delivered event. */
-export type ForwardedEvent = {
-    target: MonitorRecord["target"];
-    monitorID: string;
-    source: MonitorRecord["source"];
-    event: MonitorEvent;
-};
-/** `SOURCEFED_FORWARD_URL` (and optional `SOURCEFED_FORWARD_TOKEN`), when set. */
-export declare function forwardFromEnv(): ForwardOptions | undefined;
-/**
- * Delivers to `inner`, then POSTs a copy of each delivered event to another
- * local consumer. Forwarding never blocks or fails delivery.
- */
-export declare class ForwardingEventSink implements MonitorEventSink {
-    private readonly inner;
-    private readonly options;
-    constructor(inner: MonitorEventSink, options: ForwardOptions);
-    deliver(input: {
-        monitor: MonitorRecord;
-        event: MonitorEvent;
-    }): Promise<{
-        ok: boolean;
-        error?: string;
-    }>;
-    private forward;
-}

package/dist.dts/packages/daemon/src/utils/gate.d.ts

@@ -1,33 +0,0 @@
-import type { MonitorEvent, MonitorEventSink, MonitorRecord } from "@fdcn/sourcefed/core";
-export type GateOptions = {
-    url: string;
-    token?: string;
-    fetch?: typeof fetch;
-};
-/** The JSON body POSTed for each event; the gate replies `{ "deliver": boolean }`. */
-export type GatedEvent = {
-    target: MonitorRecord["target"];
-    monitorID: string;
-    source: MonitorRecord["source"];
-    event: MonitorEvent;
-};
-/** `SOURCEFED_GATE_URL` (and optional `SOURCEFED_GATE_TOKEN`), when set. */
-export declare function gateFromEnv(): GateOptions | undefined;
-/**
- * Asks another local consumer whether each event should reach the session.
- * Only an explicit `{ "deliver": false }` withholds it; a failed, slow, or
- * unclear answer delivers, so the gate can never lose an event.
- */
-export declare class GatedEventSink implements MonitorEventSink {
-    private readonly inner;
-    private readonly options;
-    constructor(inner: MonitorEventSink, options: GateOptions);
-    deliver(input: {
-        monitor: MonitorRecord;
-        event: MonitorEvent;
-    }): Promise<{
-        ok: boolean;
-        error?: string;
-    }>;
-    private withheld;
-}

package/dist.dts/packages/daemon/src/utils/request-router.d.ts

@@ -1,11 +0,0 @@
-export declare class RequestRouter {
-    private readonly pending;
-    private cursor;
-    nextID(): number;
-    register(id: number): Promise<unknown>;
-    settle(id: number, frame: {
-        result?: unknown;
-        error?: string;
-    }): void;
-    rejectAll(error: Error): void;
-}