@fdcn/sourcefed 0.2.0

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

@@ -0,0 +1,20 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+type OpenCodeClient = ReturnType<typeof createOpencodeClient>;
+export declare class OpenCodeBridge {
+    private readonly opencode;
+    private daemon?;
+    private readonly listeners;
+    private lastAttemptAt;
+    private lastError;
+    constructor(opencode: OpenCodeClient);
+    start(): Promise<void>;
+    ensureTarget(sessionID: string): Promise<void>;
+    callTool(name: string, arguments_: Record<string, unknown>, sessionID: string): Promise<unknown>;
+    close(): Promise<void>;
+    private ensureDaemon;
+    private routeEvents;
+    private target;
+}
+export declare function setOpenCodeBridge(bridge: OpenCodeBridge): void;
+export declare function getOpenCodeBridge(): OpenCodeBridge;
+export {};

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

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const Sourcefed: Plugin;
+export default Sourcefed;

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

@@ -0,0 +1 @@
+export declare function callMonitorTool(name: string, arguments_: Record<string, unknown>, sessionID: string): Promise<string>;

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

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+declare const definition: ToolDefinition;
+export default definition;

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

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+declare const definition: ToolDefinition;
+export default definition;

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

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+declare const definition: ToolDefinition;
+export default definition;

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

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+declare const definition: ToolDefinition;
+export default definition;

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

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+declare const definition: ToolDefinition;
+export default definition;

package/dist.dts/adapters/opencode/tui/plugin.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+export declare const sourcefedTui: TuiPlugin;

package/dist.dts/adapters/opencode/tui/sidebar.d.ts

@@ -0,0 +1,13 @@
+/** @jsxImportSource @opentui/solid */
+import { type MonitorView } from "@fdcn/sourcefed/daemon";
+import type { TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/plugin/tui";
+export type SidebarProps = {
+    api: TuiPluginApi;
+    sessionID: string;
+};
+export declare function Sidebar(props: SidebarProps): import("solid-js").JSX.Element;
+export declare function MonitorRows(props: {
+    monitors: () => MonitorView[];
+    theme: TuiThemeCurrent;
+    compact?: boolean;
+}): import("solid-js").JSX.Element;

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

@@ -0,0 +1,7 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+export declare const id = "sourcefed-tui";
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;

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

@@ -0,0 +1,12 @@
+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";
+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/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function sourcefedExtension(pi: ExtensionAPI): Promise<void>;

package/dist.dts/index.d.ts

@@ -0,0 +1 @@
+export { default, Sourcefed } from "./adapters/opencode/index.js";

package/dist.dts/packages/cli/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(argv?: string[]): Promise<void>;

package/dist.dts/packages/cli/src/skills/command.d.ts

@@ -0,0 +1 @@
+export declare function runSkillsCommand(args: string[]): Promise<void>;

package/dist.dts/packages/cli/src/skills/discovery.d.ts

@@ -0,0 +1,7 @@
+export type SkillInfo = {
+    name: string;
+    description: string;
+    dir: string;
+    hidden: boolean;
+};
+export declare function discoverSkills(): Promise<SkillInfo[]>;

package/dist.dts/packages/cli/src/skills/frontmatter.d.ts

@@ -0,0 +1,5 @@
+export declare function parseFrontmatter(content: string): {
+    name: string;
+    description: string;
+    hidden: boolean;
+} | undefined;

package/dist.dts/packages/cli/src/skills/index.d.ts

@@ -0,0 +1 @@
+export { runSkillsCommand } from "./command.js";

package/dist.dts/packages/core/src/events.d.ts

@@ -0,0 +1,24 @@
+import type { MonitorRecord } from "./monitors";
+import type { MonitorEvent, MonitorEventQueue, MonitorEventSink, MonitorTarget, QueuedMonitorEvent } from "./types";
+export declare class QueueMonitorEventSink implements MonitorEventSink {
+    readonly queue: MonitorEventQueue;
+    constructor(queue: MonitorEventQueue);
+    deliver(input: {
+        monitor: MonitorRecord;
+        event: MonitorEvent;
+    }): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+}
+export declare class InMemoryMonitorEventQueue implements MonitorEventQueue {
+    private readonly events;
+    enqueue(input: {
+        monitor: MonitorRecord;
+        event: MonitorEvent;
+    }): Promise<QueuedMonitorEvent>;
+    read(target: MonitorTarget): Promise<QueuedMonitorEvent[]>;
+    acknowledge(target: MonitorTarget, eventIDs: string[]): Promise<void>;
+}
+export declare function createQueuedMonitorEvent(monitor: MonitorRecord, event: MonitorEvent): QueuedMonitorEvent;
+export declare function monitorEventID(event: MonitorEvent): string;

package/dist.dts/packages/core/src/events.test.d.ts

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

package/dist.dts/packages/core/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./monitors";
+export * from "./runtime.js";
+export * from "./events.js";
+export * from "./sources";
+export * from "./types";
+export * from "./storage";
+export { eventToText } from "./utils/event-to-text.js";
+export { toMonitorEvent } from "./utils/to-monitor-event.js";
+export { MonitorRecordSchema, MonitorRegistrySchema } from "./monitors/schema.js";

package/dist.dts/packages/core/src/monitors/index.d.ts

@@ -0,0 +1,6 @@
+export { Monitor } from "./monitor.js";
+export { MonitorService, type CreateMonitorInput, type CreateMonitorResult } from "./service.js";
+export { dedupeActiveMonitors, monitorIdentity } from "./utils/monitor-identity.js";
+export { PollMonitor, mergeCursors } from "./poll";
+export { WebhookMonitor } from "./webhook";
+export type { MonitorRecord, MonitorRegistry } from "./types";

package/dist.dts/packages/core/src/monitors/monitor.d.ts

@@ -0,0 +1,26 @@
+import type { MonitorContext, MonitorEvent, MonitorOptions } from "#sourcefed/types";
+import type { MonitorSource, SourceInput } from "#sourcefed/sources";
+import type { Delivery, MonitorCreateInput } from "#sourcefed/types";
+import type { MonitorRecord } from "./types";
+import type { PollMonitor } from "./poll";
+import type { WebhookMonitor } from "./webhook";
+export declare abstract class Monitor<TSource extends MonitorSource = MonitorSource> {
+    readonly type: TSource["type"];
+    private readonly schema;
+    abstract readonly key: (source: TSource) => string;
+    abstract build(input: MonitorCreateInput): SourceInput;
+    /** Provider-specific display surface (nerd font icon, labels, describe). */
+    abstract readonly icon: string;
+    abstract readonly label: (source: TSource) => string;
+    abstract readonly detail: (source: TSource) => string;
+    abstract readonly describe: (source: TSource) => string;
+    readonly poll?: PollMonitor<TSource>;
+    readonly webhook?: WebhookMonitor<TSource>;
+    protected constructor(options: MonitorOptions<TSource>);
+    validateSource(source: unknown): TSource;
+    initialDelivery(source: unknown): Delivery;
+    resolveDelivery(monitor: MonitorRecord): Delivery | undefined;
+    tick(context: MonitorContext, record: MonitorRecord): Promise<number>;
+    deliver(context: MonitorContext, record: MonitorRecord, event: MonitorEvent, deliveryId: string): Promise<number>;
+    unresponsive(record: MonitorRecord, now?: number): boolean;
+}

package/dist.dts/packages/core/src/monitors/poll/index.d.ts

@@ -0,0 +1 @@
+export { PollMonitor, mergeCursors } from "./monitor.js";

package/dist.dts/packages/core/src/monitors/poll/monitor.d.ts

@@ -0,0 +1,12 @@
+import type { MonitorSource } from "#sourcefed/sources";
+import type { MonitorContext } from "#sourcefed/types";
+import type { MonitorRecord } from "../types";
+import type { Monitor } from "../monitor";
+import { type PollMonitorOptions } from "./types";
+export declare class PollMonitor<TSource extends MonitorSource = MonitorSource> {
+    private readonly options;
+    constructor(options: PollMonitorOptions<TSource>);
+    run(context: MonitorContext, source: Monitor<TSource>, record: MonitorRecord): Promise<number>;
+    isUnresponsive(record: MonitorRecord, now: number): boolean;
+}
+export declare function mergeCursors(current: unknown, result: unknown): unknown;

package/dist.dts/packages/core/src/monitors/poll/types/index.d.ts

@@ -0,0 +1,2 @@
+export type { PollMonitorOptions } from "./poll-monitor-options.js";
+export { RoutedEventCursorSchema } from "./routed-event-cursor.js";

package/dist.dts/packages/core/src/monitors/poll/types/poll-monitor-options.d.ts

@@ -0,0 +1,6 @@
+import type { MonitorSource } from "#sourcefed/sources";
+import type { PollRunner } from "./poll-runner.js";
+export type PollMonitorOptions<TSource extends MonitorSource> = {
+    run: PollRunner<TSource>;
+    mergeCursor?: (current: unknown, result: unknown) => unknown;
+};

package/dist.dts/packages/core/src/monitors/poll/types/poll-runner.d.ts

@@ -0,0 +1,3 @@
+import type { MonitorSource } from "#sourcefed/sources";
+import type { SourcePollResult } from "#sourcefed/types";
+export type PollRunner<TSource extends MonitorSource> = (source: TSource, cursor: unknown) => Promise<SourcePollResult>;

package/dist.dts/packages/core/src/monitors/poll/types/routed-event-cursor.d.ts

@@ -0,0 +1,2 @@
+import * as v from "valibot";
+export declare const RoutedEventCursorSchema: v.ArraySchema<v.StringSchema<undefined>, undefined>;

package/dist.dts/packages/core/src/monitors/poll/utils/event-delivery-id.d.ts

@@ -0,0 +1,2 @@
+import type { MonitorEvent } from "#sourcefed/types";
+export declare function eventDeliveryId(event: MonitorEvent): string;

package/dist.dts/packages/core/src/monitors/poll/utils/tick.d.ts

@@ -0,0 +1,2 @@
+import type { MonitorContext } from "#sourcefed/types";
+export declare function tick(context: MonitorContext): Promise<void>;

package/dist.dts/packages/core/src/monitors/schema.d.ts

@@ -0,0 +1,37 @@
+import * as v from "valibot";
+export declare const MonitorRecordSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly source: v.IntersectSchema<[v.ObjectSchema<{
+        readonly type: v.StringSchema<undefined>;
+    }, undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>], undefined>;
+    readonly delivery: v.PicklistSchema<["poll", "webhook"], undefined>;
+    readonly target: v.ObjectSchema<{
+        readonly kind: v.StringSchema<undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly pollIntervalSec: v.NumberSchema<undefined>;
+    readonly enabled: v.BooleanSchema<undefined>;
+    readonly createdAt: v.StringSchema<undefined>;
+    readonly updatedAt: v.StringSchema<undefined>;
+    readonly cursors: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+}, undefined>;
+export declare const MonitorRegistrySchema: v.ObjectSchema<{
+    readonly monitors: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly source: v.IntersectSchema<[v.ObjectSchema<{
+            readonly type: v.StringSchema<undefined>;
+        }, undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>], undefined>;
+        readonly delivery: v.PicklistSchema<["poll", "webhook"], undefined>;
+        readonly target: v.ObjectSchema<{
+            readonly kind: v.StringSchema<undefined>;
+            readonly id: v.StringSchema<undefined>;
+        }, undefined>;
+        readonly pollIntervalSec: v.NumberSchema<undefined>;
+        readonly enabled: v.BooleanSchema<undefined>;
+        readonly createdAt: v.StringSchema<undefined>;
+        readonly updatedAt: v.StringSchema<undefined>;
+        readonly cursors: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;

package/dist.dts/packages/core/src/monitors/service.d.ts

@@ -0,0 +1,35 @@
+import type { MonitorSource } from "#sourcefed/sources";
+import type { MonitorStore, MonitorTarget } from "#sourcefed/types";
+import type { MonitorRecord } from "./types";
+export type CreateMonitorInput = {
+    name: string;
+    source: MonitorSource;
+    delivery: "poll" | "webhook";
+    target: MonitorTarget;
+    pollIntervalSec: number;
+};
+export type CreateMonitorResult = {
+    monitor: MonitorRecord;
+    created: boolean;
+};
+export declare class MonitorService {
+    readonly store: MonitorStore;
+    private registryQueue;
+    constructor(store: MonitorStore);
+    list(): Promise<MonitorRecord[]>;
+    get(id: string): Promise<MonitorRecord | undefined>;
+    create(input: CreateMonitorInput): Promise<CreateMonitorResult>;
+    stop(id: string): Promise<MonitorRecord | {
+        error: string;
+    }>;
+    start(id: string): Promise<MonitorRecord | {
+        error: string;
+    }>;
+    remove(id: string): Promise<void>;
+    setDelivery(id: string, delivery: "poll" | "webhook"): Promise<void>;
+    updateCursor(monitor: MonitorRecord, key: string, value: unknown): Promise<void>;
+    updateCursorValue(monitor: MonitorRecord, key: string, update: (cursor: unknown) => unknown): Promise<void>;
+    dedupe(): Promise<number>;
+    private updateMonitor;
+    private transact;
+}

package/dist.dts/packages/core/src/monitors/service.test.d.ts

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

package/dist.dts/packages/core/src/monitors/transport.test.d.ts

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

package/dist.dts/packages/core/src/monitors/types/index.d.ts

@@ -0,0 +1,2 @@
+export type { MonitorRecord } from "./monitor-record.js";
+export type { MonitorRegistry } from "./monitor-registry.js";

package/dist.dts/packages/core/src/monitors/types/monitor-record.d.ts

@@ -0,0 +1,3 @@
+import type * as v from "valibot";
+import type { MonitorRecordSchema } from "../schema.js";
+export type MonitorRecord = v.InferOutput<typeof MonitorRecordSchema>;

package/dist.dts/packages/core/src/monitors/types/monitor-registry.d.ts

@@ -0,0 +1,3 @@
+import type * as v from "valibot";
+import type { MonitorRegistrySchema } from "../schema.js";
+export type MonitorRegistry = v.InferOutput<typeof MonitorRegistrySchema>;

package/dist.dts/packages/core/src/monitors/utils/monitor-identity.d.ts

@@ -0,0 +1,5 @@
+import type { MonitorSource } from "#sourcefed/sources";
+import type { MonitorTarget } from "#sourcefed/types";
+import type { MonitorRecord } from "../types";
+export declare function monitorIdentity(target: MonitorTarget, source: MonitorSource): string;
+export declare function dedupeActiveMonitors(monitors: MonitorRecord[]): MonitorRecord[];

package/dist.dts/packages/core/src/monitors/utils/monitor-identity.test.d.ts

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

package/dist.dts/packages/core/src/monitors/webhook/index.d.ts

@@ -0,0 +1 @@
+export { WebhookMonitor } from "./monitor.js";

package/dist.dts/packages/core/src/monitors/webhook/monitor.d.ts

@@ -0,0 +1,24 @@
+import type { MonitorContext, MonitorEvent } from "#sourcefed/types";
+import type { MonitorSource } from "#sourcefed/sources";
+import type { MonitorRecord } from "../types";
+import type { Monitor } from "../monitor";
+import { type WebhookMonitorOptions } from "./types";
+export declare class WebhookMonitor<TSource extends MonitorSource = MonitorSource> {
+    readonly path: string;
+    readonly preferred: boolean;
+    readonly configured: () => boolean;
+    readonly verify: (body: string, request: Request) => boolean;
+    readonly acknowledgeBeforeDelivery: boolean;
+    readonly challenge?: (payload: unknown) => Record<string, string> | undefined;
+    readonly deliveryId: (request: Request, payload: unknown) => string | undefined;
+    readonly eventName: (request: Request, payload: unknown) => string;
+    readonly parse: (payload: unknown, eventName: string, deliveryId: string) => MonitorEvent | undefined;
+    readonly updateCursor?: (event: MonitorEvent, cursor: unknown) => unknown;
+    constructor(options: WebhookMonitorOptions);
+    isHealthy(record: MonitorRecord): boolean;
+    isUnresponsive(record: MonitorRecord, now: number): boolean;
+    retryPending(context: MonitorContext, source: Monitor<TSource>, record: MonitorRecord): Promise<number>;
+    private addPending;
+    private removePending;
+    deliver(context: MonitorContext, source: Monitor<TSource>, record: MonitorRecord, event: MonitorEvent, deliveryId: string): Promise<number>;
+}

package/dist.dts/packages/core/src/monitors/webhook/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { WebhookMonitorOptions } from "./webhook-monitor-options.js";
+export { PendingWebhookEventsSchema } from "./pending-webhook-event.js";
+export type { PendingWebhookEvent } from "./pending-webhook-event.js";

package/dist.dts/packages/core/src/monitors/webhook/types/pending-webhook-event.d.ts

@@ -0,0 +1,19 @@
+import * as v from "valibot";
+import type { MonitorEvent } from "#sourcefed/types";
+export type PendingWebhookEvent = {
+    deliveryId: string;
+    event: MonitorEvent;
+};
+export declare const PendingWebhookEventsSchema: v.ArraySchema<v.ObjectSchema<{
+    readonly deliveryId: v.StringSchema<undefined>;
+    readonly event: v.ObjectSchema<{
+        readonly source: v.UnknownSchema;
+        readonly kind: v.StringSchema<undefined>;
+        readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly at: v.StringSchema<undefined>;
+        readonly summary: v.StringSchema<undefined>;
+        readonly body: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly actionable: v.BooleanSchema<undefined>;
+        readonly terminal: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>, undefined>;

package/dist.dts/packages/core/src/monitors/webhook/types/webhook-monitor-options.d.ts

@@ -0,0 +1,13 @@
+import type { MonitorEvent } from "#sourcefed/types";
+export type WebhookMonitorOptions = {
+    path: string;
+    preferred?: boolean;
+    configured: () => boolean;
+    verify: (body: string, request: Request) => boolean;
+    acknowledgeBeforeDelivery?: boolean;
+    challenge?: (payload: unknown) => Record<string, string> | undefined;
+    deliveryId: (request: Request, payload: unknown) => string | undefined;
+    eventName: (request: Request, payload: unknown) => string;
+    parse: (payload: unknown, eventName: string, deliveryId: string) => MonitorEvent | undefined;
+    updateCursor?: (event: MonitorEvent, cursor: unknown) => unknown;
+};

package/dist.dts/packages/core/src/monitors/webhook/utils/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const WEBHOOK_STALE_MS = 90000;
+export declare const WEBHOOK_STARTUP_GRACE_MS = 120000;

package/dist.dts/packages/core/src/monitors/webhook/utils/deliver-webhook.d.ts

@@ -0,0 +1,3 @@
+import type { MonitorContext, MonitorEvent } from "#sourcefed/types";
+import type { Monitor } from "../../monitor";
+export declare function deliverWebhook(context: MonitorContext, source: Monitor, event: MonitorEvent, deliveryId: string): Promise<number>;

package/dist.dts/packages/core/src/monitors/webhook/utils/handle-webhook.d.ts

@@ -0,0 +1,2 @@
+import type { MonitorContext } from "#sourcefed/types";
+export declare function handleWebhook(request: Request, context: MonitorContext): Promise<Response>;

package/dist.dts/packages/core/src/monitors/webhook/utils/handle-webhook.test.d.ts

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

package/dist.dts/packages/core/src/monitors/webhook/utils/heartbeat-webhooks.d.ts

@@ -0,0 +1,3 @@
+import type { MonitorContext } from "#sourcefed/types";
+import type { Monitor } from "../../monitor";
+export declare function heartbeatWebhooks(context: MonitorContext, source: Monitor, eventSource: unknown): Promise<void>;

package/dist.dts/packages/core/src/runtime.d.ts

@@ -0,0 +1,23 @@
+import type { MonitorContext, MonitorEventSink, MonitorStore } from "./types";
+import type { MonitorSourceRegistry } from "./sources";
+import { MonitorService } from "./monitors/service.js";
+import type { Monitor } from "./monitors";
+export type MonitorRuntimeOptions = {
+    store: MonitorStore;
+    sink: MonitorEventSink;
+    sources: MonitorSourceRegistry;
+    sourceForWebhookPath: (path: string) => Monitor | undefined;
+    pollLoopSec?: number;
+};
+export declare class MonitorRuntime {
+    readonly service: MonitorService;
+    readonly context: MonitorContext;
+    private timer?;
+    private readonly activeTicks;
+    constructor(options: MonitorRuntimeOptions);
+    private readonly pollLoopSec;
+    start(): Promise<void>;
+    tick(): Promise<void>;
+    webhook(request: Request): Promise<Response>;
+    stop(): Promise<boolean>;
+}

package/dist.dts/packages/core/src/runtime.test.d.ts

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

package/dist.dts/packages/core/src/sources/index.d.ts

@@ -0,0 +1 @@
+export type { MonitorSource, MonitorSourceRegistry, SourceInput } from "./types";

package/dist.dts/packages/core/src/sources/schema.d.ts

@@ -0,0 +1,4 @@
+import * as v from "valibot";
+export declare const MonitorSourceSchema: v.IntersectSchema<[v.ObjectSchema<{
+    readonly type: v.StringSchema<undefined>;
+}, undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>], undefined>;

package/dist.dts/packages/core/src/sources/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { MonitorSource } from "./monitor-source.js";
+export type { MonitorSourceRegistry } from "./source-registry.js";
+export type { SourceInput } from "./source-input.js";

package/dist.dts/packages/core/src/sources/types/monitor-source.d.ts

@@ -0,0 +1,3 @@
+export type MonitorSource = {
+    type: string;
+} & Record<string, unknown>;

package/dist.dts/packages/core/src/sources/types/source-input.d.ts

@@ -0,0 +1,4 @@
+import type { MonitorSource } from "./monitor-source.js";
+export type SourceInput = MonitorSource | {
+    error: string;
+};

package/dist.dts/packages/core/src/sources/types/source-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Monitor } from "#sourcefed/monitors";
+export type MonitorSourceRegistry = Record<string, Monitor<any>>;

package/dist.dts/packages/core/src/storage/in-memory-monitor-store.d.ts

@@ -0,0 +1,8 @@
+import type { MonitorStore } from "../types/monitor-store.js";
+import type { MonitorRegistry } from "../monitors/types/monitor-registry.js";
+export declare class InMemoryMonitorStore implements MonitorStore {
+    private registry;
+    constructor(initial?: MonitorRegistry);
+    load(): Promise<MonitorRegistry>;
+    save(registry: MonitorRegistry): Promise<void>;
+}

package/dist.dts/packages/core/src/storage/index.d.ts

@@ -0,0 +1,2 @@
+export { InMemoryMonitorStore } from "./in-memory-monitor-store.js";
+export { JsonMonitorEventQueue, JsonMonitorStore, defaultJsonMonitorStore, type JsonMonitorStoreOptions, } from "./json.js";

package/dist.dts/packages/core/src/storage/json.d.ts

@@ -0,0 +1,30 @@
+import type { MonitorRecord, MonitorRegistry } from "../monitors/types";
+import type { MonitorEvent, MonitorEventQueue, MonitorStore, MonitorTarget, QueuedMonitorEvent } from "../types";
+export type JsonMonitorStoreOptions = {
+    stateDir?: string;
+};
+export declare class JsonMonitorStore implements MonitorStore {
+    readonly stateDir: string;
+    readonly stateFile: string;
+    constructor(options?: JsonMonitorStoreOptions);
+    load(): Promise<MonitorRegistry>;
+    acquireExclusive(): Promise<() => Promise<void>>;
+    save(registry: MonitorRegistry): Promise<void>;
+    private readRaw;
+}
+export declare function defaultJsonMonitorStore(options?: JsonMonitorStoreOptions): JsonMonitorStore;
+export declare class JsonMonitorEventQueue implements MonitorEventQueue {
+    readonly stateDir: string;
+    readonly eventsFile: string;
+    private queue;
+    constructor(stateDir: string);
+    enqueue(input: {
+        monitor: MonitorRecord;
+        event: MonitorEvent;
+    }): Promise<QueuedMonitorEvent>;
+    read(target: MonitorTarget): Promise<QueuedMonitorEvent[]>;
+    acknowledge(target: MonitorTarget, eventIDs: string[]): Promise<void>;
+    private transact;
+    private loadEvents;
+    private saveEvents;
+}

package/dist.dts/packages/core/src/storage/json.test.d.ts

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

package/dist.dts/packages/core/src/types/delivery.d.ts

@@ -0,0 +1 @@
+export type Delivery = "poll" | "webhook";

package/dist.dts/packages/core/src/types/event-sink.d.ts

@@ -0,0 +1,12 @@
+import type { MonitorEvent } from "./monitor-event.js";
+import type { MonitorRecord } from "../monitors/types/monitor-record.js";
+export type EventDeliveryResult = {
+    ok: boolean;
+    error?: string;
+};
+export interface MonitorEventSink {
+    deliver(input: {
+        monitor: MonitorRecord;
+        event: MonitorEvent;
+    }): Promise<EventDeliveryResult>;
+}

package/dist.dts/packages/core/src/types/index.d.ts

@@ -0,0 +1,11 @@
+export type { Delivery } from "./delivery.js";
+export type { EventDeliveryResult, MonitorEventSink } from "./event-sink.js";
+export type { MonitorCreateInput } from "./monitor-create-input.js";
+export type { MonitorEvent } from "./monitor-event.js";
+export type { MonitorContext } from "./monitor-context.js";
+export type { MonitorEventQueue, QueuedMonitorEvent } from "./monitor-event-queue.js";
+export type { MonitorStore } from "./monitor-store.js";
+export type { MonitorTarget } from "./monitor-target.js";
+export type { SourceEvent } from "./source-event.js";
+export type { SourcePollResult } from "./source-poll-result.js";
+export type { MonitorOptions, MonitorSchema } from "./monitor-options.js";

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

@@ -0,0 +1,10 @@
+import type { MonitorEventSink } from "./event-sink.js";
+import type { Monitor } from "#sourcefed/monitors";
+import type { MonitorSourceRegistry } from "#sourcefed/sources";
+import type { MonitorService } from "../monitors/service.js";
+export type MonitorContext = {
+    service: MonitorService;
+    sink: MonitorEventSink;
+    sources: MonitorSourceRegistry;
+    sourceForWebhookPath: (path: string) => Monitor | undefined;
+};

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

@@ -0,0 +1,8 @@
+export type MonitorCreateInput = {
+    issueKey?: string;
+    repo?: string;
+    prNumber?: number;
+    channelId?: string;
+    threadTs?: string;
+    threadUrl?: string;
+};