@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/watchers/index.js

@@ -0,0 +1,2 @@
+export { WatcherRegistry } from './registry.js';
+export { getWatcherStorePath, loadWatcherSnapshot, loadWatcherSnapshotFromPath, resolveWatcherStorePath, saveWatcherSnapshot, saveWatcherSnapshotToPath, } from '@pellux/goodvibes-sdk/platform/watchers/store';

package/dist/_internal/platform/watchers/registry.d.ts

@@ -0,0 +1,51 @@
+import type { RuntimeStore } from '../runtime/store/index.js';
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+import type { WatcherKind, WatcherRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/watchers';
+import type { AutomationSourceRecord } from '@pellux/goodvibes-sdk/platform/automation/sources';
+export interface RegisterWatcherInput {
+    readonly id: string;
+    readonly label: string;
+    readonly kind?: WatcherKind;
+    readonly source: AutomationSourceRecord;
+    readonly intervalMs?: number;
+    readonly metadata?: Record<string, unknown>;
+    readonly run?: () => Promise<string | void> | string | void;
+}
+export interface RegisterPollingWatcherInput {
+    readonly id: string;
+    readonly label: string;
+    readonly source: AutomationSourceRecord;
+    readonly intervalMs: number;
+    readonly run: () => Promise<string | void> | string | void;
+}
+export interface WatcherRegistryOptions {
+    readonly storePath?: string;
+}
+export declare class WatcherRegistry {
+    private readonly watchers;
+    private readonly timers;
+    private readonly inFlight;
+    private readonly storePath;
+    private runtimeDispatch;
+    private runtimeBus;
+    private loaded;
+    constructor(options?: WatcherRegistryOptions);
+    attachRuntime(config: {
+        readonly runtimeStore?: RuntimeStore | null;
+        readonly runtimeBus?: RuntimeEventBus | null;
+    }): void;
+    registerWatcher(input: RegisterWatcherInput): WatcherRecord;
+    registerPollingWatcher(input: RegisterPollingWatcherInput): WatcherRecord;
+    list(): WatcherRecord[];
+    getWatcher(id: string): WatcherRecord | null;
+    startWatcher(id: string): WatcherRecord | null;
+    stopWatcher(id: string, reason?: string): WatcherRecord | null;
+    runWatcherNow(id: string): Promise<WatcherRecord | null>;
+    removeWatcher(id: string): boolean;
+    private ensureLoaded;
+    private normalizeRecord;
+    private runWatcher;
+    private buildRunStrategy;
+    private persist;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/_internal/platform/watchers/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/watchers/registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAuB,MAAM,+DAA+D,CAAC;AACrI,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mDAAmD,CAAC;AAehG,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACxC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC;CAC7D;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC;CAC5D;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAwFD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwC;IACjE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqD;IAC5E,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,eAAe,CAA+B;IACtD,OAAO,CAAC,UAAU,CAAgC;IAClD,OAAO,CAAC,MAAM,CAAS;gBAEX,OAAO,GAAE,sBAA2B;IAIhD,aAAa,CAAC,MAAM,EAAE;QACpB,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;QAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;KAC9C,GAAG,IAAI;IAYR,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,aAAa;IAuC3D,sBAAsB,CAAC,KAAK,EAAE,2BAA2B,GAAG,aAAa;IAezE,IAAI,IAAI,aAAa,EAAE;IAkBvB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAa5C,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAuC9C,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,SAAY,GAAG,aAAa,GAAG,IAAI;IA8B3D,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAQ9D,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAoBlC,OAAO,CAAC,YAAY;IAkCpB,OAAO,CAAC,eAAe;YAYT,UAAU;IA4DxB,OAAO,CAAC,gBAAgB;IA+DxB,OAAO,CAAC,OAAO;CAShB"}

package/dist/_internal/platform/watchers/registry.js

@@ -0,0 +1,447 @@
+import { existsSync, statSync } from 'node:fs';
+import { createDomainDispatch } from '../runtime/store/index.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+import { emitWatcherFailed, emitWatcherHeartbeat, emitWatcherStarted, emitWatcherStopped, } from '../runtime/emitters/index.js';
+import { loadWatcherSnapshotFromPath, resolveWatcherStorePath, saveWatcherSnapshotToPath, } from '@pellux/goodvibes-sdk/platform/watchers/store';
+function now() {
+    return Date.now();
+}
+function sortWatchers(watchers) {
+    return [...watchers].sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
+}
+function toWatcherSourceKind(kind) {
+    switch (kind) {
+        case 'webhook':
+            return 'webhook';
+        case 'filesystem':
+            return 'file';
+        case 'socket':
+            return 'stream';
+        case 'integration':
+            return 'api';
+        case 'manual':
+            return 'api';
+        case 'polling':
+        default:
+            return 'poll';
+    }
+}
+function sourceStatusFor(record, ts = now()) {
+    const lastSeenAt = record.lastHeartbeatAt ?? record.source.lastSeenAt ?? record.source.updatedAt ?? record.source.createdAt;
+    if (record.state === 'failed') {
+        return {
+            sourceLagMs: lastSeenAt ? Math.max(0, ts - lastSeenAt) : undefined,
+            sourceStatus: 'failed',
+            degradedReason: record.lastError ?? 'watcher failed',
+            nextState: 'failed',
+        };
+    }
+    if (record.state === 'stopped') {
+        return {
+            sourceLagMs: lastSeenAt ? Math.max(0, ts - lastSeenAt) : undefined,
+            sourceStatus: 'unknown',
+        };
+    }
+    if (!lastSeenAt) {
+        return {
+            sourceStatus: 'lagging',
+            degradedReason: 'watcher has not reported a heartbeat yet',
+            nextState: 'degraded',
+        };
+    }
+    const interval = Math.max(1_000, Number(record.intervalMs ?? 0) || 0);
+    const lag = Math.max(0, ts - lastSeenAt);
+    const staleThreshold = interval > 0 ? interval * 2 : 60_000;
+    if (lag >= staleThreshold) {
+        return {
+            sourceLagMs: lag,
+            sourceStatus: 'stale',
+            degradedReason: `heartbeat stale by ${lag}ms`,
+            nextState: 'degraded',
+        };
+    }
+    if (interval > 0 && lag >= interval) {
+        return {
+            sourceLagMs: lag,
+            sourceStatus: 'lagging',
+            degradedReason: `heartbeat lagging by ${lag}ms`,
+            nextState: 'degraded',
+        };
+    }
+    return {
+        sourceLagMs: lag,
+        sourceStatus: record.lastError ? 'degraded' : 'healthy',
+        ...(record.lastError ? { degradedReason: record.lastError } : {}),
+        nextState: record.state === 'degraded' && !record.lastError ? 'running' : undefined,
+    };
+}
+export class WatcherRegistry {
+    watchers = new Map();
+    timers = new Map();
+    inFlight = new Set();
+    storePath;
+    runtimeDispatch = null;
+    runtimeBus = null;
+    loaded = false;
+    constructor(options = {}) {
+        this.storePath = resolveWatcherStorePath(options.storePath);
+    }
+    attachRuntime(config) {
+        if (config.runtimeStore) {
+            this.runtimeDispatch = createDomainDispatch(config.runtimeStore);
+            for (const watcher of this.watchers.values()) {
+                this.runtimeDispatch.syncWatcher(this.normalizeRecord(watcher.record), 'watchers.attach');
+            }
+        }
+        if (config.runtimeBus) {
+            this.runtimeBus = config.runtimeBus;
+        }
+    }
+    registerWatcher(input) {
+        this.ensureLoaded();
+        const existing = this.watchers.get(input.id)?.record;
+        const wasRunning = existing?.state === 'running' || existing?.state === 'starting' || existing?.state === 'degraded';
+        const timer = this.timers.get(input.id);
+        if (timer) {
+            clearInterval(timer);
+            this.timers.delete(input.id);
+        }
+        const record = this.normalizeRecord({
+            id: input.id,
+            kind: input.kind ?? existing?.kind ?? 'polling',
+            label: input.label,
+            state: existing?.state ?? 'stopped',
+            source: input.source,
+            intervalMs: input.intervalMs ?? existing?.intervalMs,
+            lastHeartbeatAt: existing?.lastHeartbeatAt,
+            lastCheckpoint: existing?.lastCheckpoint,
+            lastError: existing?.lastError,
+            sourceLagMs: existing?.sourceLagMs,
+            sourceStatus: existing?.sourceStatus,
+            degradedReason: existing?.degradedReason,
+            metadata: {
+                ...(existing?.metadata ?? {}),
+                ...(input.metadata ?? {}),
+            },
+        });
+        this.watchers.set(record.id, {
+            record,
+            run: input.run ?? this.buildRunStrategy(record),
+        });
+        this.persist();
+        this.runtimeDispatch?.syncWatcher(record, 'watchers.register');
+        if (wasRunning) {
+            return this.startWatcher(record.id) ?? record;
+        }
+        return record;
+    }
+    registerPollingWatcher(input) {
+        return this.registerWatcher({
+            id: input.id,
+            label: input.label,
+            kind: 'polling',
+            source: input.source,
+            intervalMs: input.intervalMs,
+            metadata: {
+                ...input.source.metadata,
+                runMode: 'polling',
+            },
+            run: input.run,
+        });
+    }
+    list() {
+        this.ensureLoaded();
+        const refreshed = [];
+        let changed = false;
+        for (const watcher of this.watchers.values()) {
+            const normalized = this.normalizeRecord(watcher.record);
+            refreshed.push(normalized);
+            if (normalized !== watcher.record) {
+                this.watchers.set(normalized.id, { ...watcher, record: normalized });
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.persist();
+        }
+        return sortWatchers(refreshed);
+    }
+    getWatcher(id) {
+        this.ensureLoaded();
+        const watcher = this.watchers.get(id);
+        if (!watcher)
+            return null;
+        const normalized = this.normalizeRecord(watcher.record);
+        if (normalized !== watcher.record) {
+            this.watchers.set(id, { ...watcher, record: normalized });
+            this.persist();
+            this.runtimeDispatch?.syncWatcher(normalized, 'watchers.refresh');
+        }
+        return normalized;
+    }
+    startWatcher(id) {
+        this.ensureLoaded();
+        const watcher = this.watchers.get(id);
+        if (!watcher)
+            return null;
+        if (this.timers.has(id))
+            return watcher.record;
+        const started = this.normalizeRecord({
+            ...watcher.record,
+            state: 'running',
+            lastHeartbeatAt: now(),
+            sourceStatus: 'healthy',
+            degradedReason: undefined,
+            sourceLagMs: 0,
+        });
+        this.watchers.set(id, { ...watcher, record: started });
+        this.persist();
+        this.runtimeDispatch?.syncWatcher(started, 'watchers.start');
+        if (this.runtimeBus) {
+            emitWatcherStarted(this.runtimeBus, {
+                sessionId: 'watchers',
+                source: 'watcher-registry',
+                traceId: id,
+            }, {
+                watcherId: id,
+                sourceKind: toWatcherSourceKind(started.kind),
+                name: started.label,
+            });
+        }
+        if (started.kind !== 'manual' && Number(started.intervalMs ?? 0) > 0) {
+            const timer = setInterval(() => {
+                void this.runWatcher(id);
+            }, started.intervalMs ?? 60_000);
+            this.timers.set(id, timer);
+            void this.runWatcher(id);
+        }
+        return started;
+    }
+    stopWatcher(id, reason = 'stopped') {
+        this.ensureLoaded();
+        const watcher = this.watchers.get(id);
+        if (!watcher)
+            return null;
+        const timer = this.timers.get(id);
+        if (timer)
+            clearInterval(timer);
+        this.timers.delete(id);
+        const stopped = this.normalizeRecord({
+            ...watcher.record,
+            state: 'stopped',
+            sourceStatus: 'unknown',
+        });
+        this.watchers.set(id, { ...watcher, record: stopped });
+        this.persist();
+        this.runtimeDispatch?.syncWatcher(stopped, 'watchers.stop');
+        if (this.runtimeBus) {
+            emitWatcherStopped(this.runtimeBus, {
+                sessionId: 'watchers',
+                source: 'watcher-registry',
+                traceId: id,
+            }, {
+                watcherId: id,
+                sourceKind: toWatcherSourceKind(stopped.kind),
+                reason,
+            });
+        }
+        return stopped;
+    }
+    async runWatcherNow(id) {
+        this.ensureLoaded();
+        const watcher = this.watchers.get(id);
+        if (!watcher)
+            return null;
+        await this.runWatcher(id);
+        return this.getWatcher(id);
+    }
+    removeWatcher(id) {
+        this.ensureLoaded();
+        const watcher = this.watchers.get(id);
+        if (!watcher)
+            return false;
+        this.stopWatcher(id, 'removed');
+        const removed = this.watchers.delete(id);
+        if (removed) {
+            this.persist();
+            this.runtimeDispatch?.syncWatcher({
+                ...watcher.record,
+                state: 'stopped',
+                metadata: {
+                    ...watcher.record.metadata,
+                    removed: true,
+                },
+            }, 'watchers.remove');
+        }
+        return removed;
+    }
+    ensureLoaded() {
+        if (this.loaded)
+            return;
+        const snapshot = loadWatcherSnapshotFromPath(this.storePath);
+        if (snapshot) {
+            this.watchers.clear();
+            for (const record of snapshot.watchers) {
+                const normalized = this.normalizeRecord(record);
+                this.watchers.set(normalized.id, {
+                    record: normalized,
+                    run: this.buildRunStrategy(normalized),
+                });
+            }
+        }
+        this.loaded = true;
+        for (const watcher of this.watchers.values()) {
+            const normalized = this.normalizeRecord(watcher.record);
+            this.watchers.set(normalized.id, {
+                ...watcher,
+                record: normalized,
+                run: watcher.run ?? this.buildRunStrategy(normalized),
+            });
+            if ((normalized.state === 'running' || normalized.state === 'degraded' || normalized.state === 'starting')
+                && normalized.kind !== 'manual'
+                && Number(normalized.intervalMs ?? 0) > 0) {
+                const timer = setInterval(() => {
+                    void this.runWatcher(normalized.id);
+                }, normalized.intervalMs ?? 60_000);
+                this.timers.set(normalized.id, timer);
+            }
+        }
+    }
+    normalizeRecord(record) {
+        const freshness = sourceStatusFor(record);
+        const state = freshness.nextState ?? record.state;
+        return {
+            ...record,
+            state,
+            ...(freshness.sourceLagMs !== undefined ? { sourceLagMs: freshness.sourceLagMs } : {}),
+            sourceStatus: freshness.sourceStatus,
+            ...(freshness.degradedReason ? { degradedReason: freshness.degradedReason } : {}),
+        };
+    }
+    async runWatcher(id) {
+        if (this.inFlight.has(id))
+            return;
+        const watcher = this.watchers.get(id);
+        if (!watcher)
+            return;
+        this.inFlight.add(id);
+        try {
+            const checkpoint = await watcher.run();
+            const updated = this.normalizeRecord({
+                ...watcher.record,
+                state: 'running',
+                lastHeartbeatAt: now(),
+                lastCheckpoint: checkpoint ? String(checkpoint) : watcher.record.lastCheckpoint,
+                lastError: undefined,
+                sourceStatus: 'healthy',
+                sourceLagMs: 0,
+                degradedReason: undefined,
+            });
+            this.watchers.set(id, { ...watcher, record: updated });
+            this.persist();
+            this.runtimeDispatch?.syncWatcher(updated, 'watchers.heartbeat');
+            if (this.runtimeBus) {
+                emitWatcherHeartbeat(this.runtimeBus, {
+                    sessionId: 'watchers',
+                    source: 'watcher-registry',
+                    traceId: id,
+                }, {
+                    watcherId: id,
+                    sourceKind: toWatcherSourceKind(updated.kind),
+                    seenAt: updated.lastHeartbeatAt ?? now(),
+                    checkpoint: updated.lastCheckpoint ?? '',
+                });
+            }
+        }
+        catch (error) {
+            const failed = this.normalizeRecord({
+                ...watcher.record,
+                state: 'failed',
+                lastError: summarizeError(error),
+                sourceStatus: 'failed',
+                degradedReason: summarizeError(error),
+            });
+            this.watchers.set(id, { ...watcher, record: failed });
+            this.persist();
+            this.runtimeDispatch?.syncWatcher(failed, 'watchers.failed');
+            if (this.runtimeBus) {
+                emitWatcherFailed(this.runtimeBus, {
+                    sessionId: 'watchers',
+                    source: 'watcher-registry',
+                    traceId: id,
+                }, {
+                    watcherId: id,
+                    sourceKind: toWatcherSourceKind(failed.kind),
+                    error: failed.lastError ?? 'watcher failed',
+                    retryable: true,
+                });
+            }
+        }
+        finally {
+            this.inFlight.delete(id);
+        }
+    }
+    buildRunStrategy(record) {
+        const metadata = record.metadata ?? {};
+        const sourceMetadata = record.source.metadata ?? {};
+        const merged = { ...sourceMetadata, ...metadata };
+        if (typeof merged.run === 'string' && merged.run.trim().length > 0) {
+            return () => merged.run;
+        }
+        if (record.kind === 'filesystem') {
+            const path = typeof merged.path === 'string' ? merged.path : typeof merged.filePath === 'string' ? merged.filePath : '';
+            return () => {
+                if (!path)
+                    return `${record.id}:filesystem-no-path`;
+                if (!existsSync(path))
+                    return `${path}:missing`;
+                const stat = statSync(path);
+                return `${path}:${stat.size}:${Math.floor(stat.mtimeMs)}`;
+            };
+        }
+        if (record.kind === 'webhook') {
+            const url = typeof merged.url === 'string' ? merged.url : '';
+            return async () => {
+                if (!url)
+                    return `${record.id}:webhook-no-url`;
+                const response = await fetch(url, {
+                    method: typeof merged.method === 'string' ? merged.method.toUpperCase() : 'GET',
+                    headers: typeof merged.headers === 'object' && merged.headers !== null
+                        ? Object.fromEntries(Object.entries(merged.headers).filter(([, value]) => typeof value === 'string'))
+                        : undefined,
+                });
+                const text = await response.text().catch(() => '');
+                return `${response.status}:${text.slice(0, 120)}`;
+            };
+        }
+        if (record.kind === 'integration') {
+            return () => `integration:${record.source.id}:${record.label}`;
+        }
+        if (record.kind === 'socket') {
+            return () => `socket:${typeof merged.address === 'string' ? merged.address : record.label}`;
+        }
+        if (record.kind === 'manual') {
+            return () => `${record.label}:${new Date().toISOString()}`;
+        }
+        const url = typeof merged.url === 'string' ? merged.url : typeof merged.endpoint === 'string' ? merged.endpoint : '';
+        if (url) {
+            return async () => {
+                const response = await fetch(url, {
+                    method: typeof merged.method === 'string' ? merged.method.toUpperCase() : 'GET',
+                    headers: typeof merged.headers === 'object' && merged.headers !== null
+                        ? Object.fromEntries(Object.entries(merged.headers).filter(([, value]) => typeof value === 'string'))
+                        : undefined,
+                });
+                const text = await response.text().catch(() => '');
+                return `${response.status}:${text.slice(0, 120)}`;
+            };
+        }
+        return () => `${record.id}:${record.kind}:${Date.now()}`;
+    }
+    persist() {
+        saveWatcherSnapshotToPath(sortWatchers([...this.watchers.values()].map((entry) => entry.record)), this.storePath);
+        for (const watcher of this.watchers.values()) {
+            this.runtimeDispatch?.syncWatcher(watcher.record, 'watchers.persist');
+        }
+    }
+}

package/dist/_internal/platform/watchers/store.js

@@ -4,7 +4,7 @@ function sortWatchers(watchers) {
     return [...watchers].sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
 }
 export function getWatcherStorePath(rootPath) {
-    return join(rootPath, '.goodvibes', 'tui', 'watchers.json');
+    return join(rootPath, '.goodvibes', 'goodvibes', 'watchers.json');
 }
 export function resolveWatcherStorePath(storePath) {
     if (!storePath) {

package/dist/_internal/platform/web-search/index.d.ts

@@ -0,0 +1,12 @@
+export type { WebSearchEvidence, WebSearchInstantAnswer, WebSearchProvider, WebSearchProviderCapability, WebSearchProviderDescriptor, WebSearchProviderResponse, WebSearchRelatedTopic, WebSearchRequest, WebSearchResponse, WebSearchResult, WebSearchResultType, WebSearchSafeSearch, WebSearchTimeRange, WebSearchVerbosity, } from '@pellux/goodvibes-sdk/platform/web-search/types';
+export { WebSearchProviderRegistry } from './provider-registry.js';
+export { WebSearchService } from './service.js';
+export type { WebSearchServiceStatus } from './service.js';
+export { createBraveSearchProvider } from './providers/brave.js';
+export { createDuckDuckGoProvider } from './providers/duckduckgo.js';
+export { createExaSearchProvider } from './providers/exa.js';
+export { createFirecrawlSearchProvider } from './providers/firecrawl.js';
+export { createPerplexitySearchProvider } from './providers/perplexity.js';
+export { createSearxngSearchProvider } from './providers/searxng.js';
+export { createTavilySearchProvider } from './providers/tavily.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/web-search/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/web-search/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,iBAAiB,EACjB,sBAAsB,EACtB,iBAAiB,EACjB,2BAA2B,EAC3B,2BAA2B,EAC3B,yBAAyB,EACzB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,YAAY,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/_internal/platform/web-search/index.js

@@ -0,0 +1,9 @@
+export { WebSearchProviderRegistry } from './provider-registry.js';
+export { WebSearchService } from './service.js';
+export { createBraveSearchProvider } from './providers/brave.js';
+export { createDuckDuckGoProvider } from './providers/duckduckgo.js';
+export { createExaSearchProvider } from './providers/exa.js';
+export { createFirecrawlSearchProvider } from './providers/firecrawl.js';
+export { createPerplexitySearchProvider } from './providers/perplexity.js';
+export { createSearxngSearchProvider } from './providers/searxng.js';
+export { createTavilySearchProvider } from './providers/tavily.js';

package/dist/_internal/platform/web-search/provider-registry.d.ts

@@ -0,0 +1,14 @@
+import type { WebSearchProvider, WebSearchProviderDescriptor } from '@pellux/goodvibes-sdk/platform/web-search/types';
+import type { SearchProviderContext } from './providers/shared.js';
+export declare class WebSearchProviderRegistry {
+    private readonly providers;
+    constructor(context: SearchProviderContext);
+    register(provider: WebSearchProvider, options?: {
+        readonly replace?: boolean;
+    }): () => void;
+    unregister(id: string): boolean;
+    get(id: string): WebSearchProvider | null;
+    list(): WebSearchProviderDescriptor[];
+    find(providerId?: string): WebSearchProvider | null;
+}
+//# sourceMappingURL=provider-registry.d.ts.map

package/dist/_internal/platform/web-search/provider-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-registry.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/web-search/provider-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,2BAA2B,EAC5B,MAAM,iDAAiD,CAAC;AAQzD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE,qBAAa,yBAAyB;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwC;gBAEtD,OAAO,EAAE,qBAAqB;IAU1C,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,EAAE,OAAO,GAAE;QAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,MAAM,IAAI;IAa/F,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI/B,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAIzC,IAAI,IAAI,2BAA2B,EAAE;IAYrC,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;CAIpD"}

package/dist/_internal/platform/web-search/provider-registry.js

@@ -0,0 +1,55 @@
+import { createBraveSearchProvider } from './providers/brave.js';
+import { createDuckDuckGoProvider } from './providers/duckduckgo.js';
+import { createExaSearchProvider } from './providers/exa.js';
+import { createFirecrawlSearchProvider } from './providers/firecrawl.js';
+import { createPerplexitySearchProvider } from './providers/perplexity.js';
+import { createSearxngSearchProvider } from './providers/searxng.js';
+import { createTavilySearchProvider } from './providers/tavily.js';
+export class WebSearchProviderRegistry {
+    providers = new Map();
+    constructor(context) {
+        this.register(createDuckDuckGoProvider(), { replace: true });
+        this.register(createSearxngSearchProvider(context), { replace: true });
+        this.register(createBraveSearchProvider(context), { replace: true });
+        this.register(createExaSearchProvider(context), { replace: true });
+        this.register(createFirecrawlSearchProvider(context), { replace: true });
+        this.register(createTavilySearchProvider(context), { replace: true });
+        this.register(createPerplexitySearchProvider(context), { replace: true });
+    }
+    register(provider, options = {}) {
+        const id = provider.id.trim();
+        if (!id)
+            throw new Error('Web search provider id is required');
+        if (this.providers.has(id) && !options.replace) {
+            throw new Error(`Web search provider already registered: ${id}`);
+        }
+        const registered = { ...provider, id };
+        this.providers.set(id, registered);
+        return () => {
+            if (this.providers.get(id) === registered)
+                this.unregister(id);
+        };
+    }
+    unregister(id) {
+        return this.providers.delete(id);
+    }
+    get(id) {
+        return this.providers.get(id) ?? null;
+    }
+    list() {
+        return [...this.providers.values()]
+            .map((provider) => provider.descriptor?.() ?? {
+            id: provider.id,
+            label: provider.label,
+            capabilities: [...provider.capabilities],
+            requiresAuth: false,
+            configured: true,
+        })
+            .sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
+    }
+    find(providerId) {
+        if (providerId)
+            return this.get(providerId);
+        return [...this.providers.values()][0] ?? null;
+    }
+}

package/dist/_internal/platform/web-search/providers/brave.d.ts

@@ -0,0 +1,4 @@
+import type { WebSearchProvider } from '@pellux/goodvibes-sdk/platform/web-search/types';
+import { type SearchProviderContext } from './shared.js';
+export declare function createBraveSearchProvider(context: SearchProviderContext): WebSearchProvider;
+//# sourceMappingURL=brave.d.ts.map

package/dist/_internal/platform/web-search/providers/brave.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brave.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/web-search/providers/brave.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAA+C,MAAM,iDAAiD,CAAC;AACtI,OAAO,EAML,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAC;AAmBrB,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,GAAG,iBAAiB,CAwE3F"}