@rainfall-devkit/sdk 0.1.8 → 0.2.1

package/dist/listeners-CTRSofnm.d.mts

@@ -0,0 +1,372 @@
+import { R as Rainfall } from './sdk-CJ9g5lFo.mjs';
+
+/**
+ * Rainfall Networked Executor - Distributed job execution via Rainfall API
+ *
+ * This service enables multi-computer networked executions without direct Redis access.
+ * All communication goes through the authenticated Rainfall API.
+ */
+
+interface NodeCapabilities {
+    /** Can execute local commands/shell */
+    localExec?: boolean;
+    /** Can watch files for changes */
+    fileWatch?: boolean;
+    /** Can listen to passive events (webhooks, etc.) */
+    passiveListen?: boolean;
+    /** Can execute browser automation */
+    browser?: boolean;
+    /** Custom capability flags */
+    custom?: string[];
+}
+interface NodeRegistration {
+    nodeId: string;
+    hostname: string;
+    capabilities: string[];
+    wsPort?: number;
+    httpPort?: number;
+    registeredAt: string;
+}
+interface QueuedJob {
+    jobId: string;
+    toolId: string;
+    params: Record<string, unknown>;
+    status: 'queued' | 'running' | 'completed' | 'failed';
+    executionMode: 'local-only' | 'distributed' | 'any';
+    requesterNodeId?: string;
+    executorNodeId?: string;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    result?: unknown;
+    error?: string;
+}
+interface NetworkedExecutorOptions {
+    /** WebSocket port for receiving push jobs */
+    wsPort?: number;
+    /** HTTP port for health checks */
+    httpPort?: number;
+    /** Node capabilities */
+    capabilities?: NodeCapabilities;
+    /** Hostname identifier */
+    hostname?: string;
+}
+declare class RainfallNetworkedExecutor {
+    private rainfall;
+    private options;
+    private nodeId?;
+    private jobCallbacks;
+    private resultPollingInterval?;
+    constructor(rainfall: Rainfall, options?: NetworkedExecutorOptions);
+    /**
+     * Register this node with the Rainfall backend
+     */
+    registerNode(): Promise<string>;
+    /**
+     * Unregister this node on shutdown
+     */
+    unregisterNode(): Promise<void>;
+    /**
+     * Queue a tool execution for distributed processing
+     * Non-blocking - returns immediately with a job ID
+     */
+    queueToolExecution(toolId: string, params: Record<string, unknown>, options?: {
+        executionMode?: 'local-only' | 'distributed' | 'any';
+        callback?: (result: unknown, error?: string) => void;
+    }): Promise<string>;
+    /**
+     * Get status of a queued job
+     */
+    getJobStatus(jobId: string): Promise<QueuedJob | null>;
+    /**
+     * Subscribe to job results via polling (WebSocket fallback)
+     * In the future, this will use WebSocket push from ApresMoi
+     */
+    subscribeToResults(callback: (jobId: string, result: unknown, error?: string) => void): Promise<void>;
+    private onResultReceived?;
+    /**
+     * Start polling for job results (fallback until WebSocket push is ready)
+     */
+    private startResultPolling;
+    /**
+     * Claim a job for execution on this node
+     */
+    claimJob(): Promise<QueuedJob | null>;
+    /**
+     * Submit job result after execution
+     */
+    submitJobResult(jobId: string, result: unknown, error?: string): Promise<void>;
+    /**
+     * Get this node's ID
+     */
+    getNodeId(): string | undefined;
+    /**
+     * Build capabilities list from options
+     */
+    private buildCapabilitiesList;
+}
+
+/**
+ * Rainfall Daemon Context - Persistent memory and session state
+ *
+ * Provides:
+ * - Persistent memory storage (local + cloud sync)
+ * - Session context for ongoing conversations/workflows
+ * - Tool execution history
+ * - Local state management
+ */
+
+interface MemoryEntry {
+    id: string;
+    content: string;
+    keywords: string[];
+    timestamp: string;
+    source?: string;
+    metadata?: Record<string, unknown>;
+}
+interface SessionContext {
+    id: string;
+    startedAt: string;
+    lastActivity: string;
+    variables: Record<string, unknown>;
+    messageHistory: Array<{
+        role: 'user' | 'assistant' | 'system' | 'tool';
+        content: string;
+        timestamp: string;
+    }>;
+}
+interface ToolExecutionRecord {
+    id: string;
+    toolId: string;
+    params: Record<string, unknown>;
+    result: unknown;
+    error?: string;
+    timestamp: string;
+    duration: number;
+    nodeId?: string;
+}
+interface ContextOptions {
+    /** Maximum number of memories to cache locally */
+    maxLocalMemories?: number;
+    /** Maximum message history per session */
+    maxMessageHistory?: number;
+    /** Maximum execution history to keep */
+    maxExecutionHistory?: number;
+    /** Session TTL in milliseconds */
+    sessionTtl?: number;
+}
+declare class RainfallDaemonContext {
+    private rainfall;
+    private options;
+    private localMemories;
+    private sessions;
+    private executionHistory;
+    private currentSessionId?;
+    constructor(rainfall: Rainfall, options?: ContextOptions);
+    /**
+     * Initialize the context - load recent memories from cloud
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create or get a session
+     */
+    getSession(sessionId?: string): SessionContext;
+    /**
+     * Get the current active session
+     */
+    getCurrentSession(): SessionContext | undefined;
+    /**
+     * Set the current active session
+     */
+    setCurrentSession(sessionId: string): void;
+    /**
+     * Add a message to the current session history
+     */
+    addMessage(role: 'user' | 'assistant' | 'system' | 'tool', content: string): void;
+    /**
+     * Store a memory (local + cloud sync)
+     */
+    storeMemory(content: string, options?: {
+        keywords?: string[];
+        source?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<string>;
+    /**
+     * Recall memories by query
+     */
+    recallMemories(query: string, topK?: number): Promise<MemoryEntry[]>;
+    /**
+     * Set a session variable
+     */
+    setVariable(key: string, value: unknown): void;
+    /**
+     * Get a session variable
+     */
+    getVariable<T = unknown>(key: string): T | undefined;
+    /**
+     * Record a tool execution
+     */
+    recordExecution(toolId: string, params: Record<string, unknown>, result: unknown, options?: {
+        error?: string;
+        duration: number;
+        nodeId?: string;
+    }): void;
+    /**
+     * Get recent execution history
+     */
+    getExecutionHistory(limit?: number): ToolExecutionRecord[];
+    /**
+     * Get execution statistics
+     */
+    getExecutionStats(): {
+        total: number;
+        successful: number;
+        failed: number;
+        averageDuration: number;
+        byTool: Record<string, number>;
+    };
+    /**
+     * Clear old sessions based on TTL
+     */
+    cleanupSessions(): void;
+    /**
+     * Get context summary for debugging
+     */
+    getStatus(): {
+        memoriesCached: number;
+        activeSessions: number;
+        currentSession?: string;
+        executionHistorySize: number;
+    };
+    private trimLocalMemories;
+}
+
+/**
+ * Rainfall Daemon Passive Listeners - File watchers, cron triggers, etc.
+ *
+ * Provides:
+ * - File system watchers for triggering workflows
+ * - Cron-style scheduled triggers
+ * - Webhook listeners (future)
+ * - Event bus for inter-node communication
+ */
+
+interface FileWatcherConfig {
+    id: string;
+    name: string;
+    watchPath: string;
+    pattern?: string;
+    events: ('create' | 'modify' | 'delete')[];
+    workflow: {
+        toolId: string;
+        params: Record<string, unknown>;
+    }[];
+    options?: {
+        recursive?: boolean;
+        ignoreInitial?: boolean;
+        debounceMs?: number;
+    };
+}
+interface CronTriggerConfig {
+    id: string;
+    name: string;
+    cron: string;
+    timezone?: string;
+    workflow: {
+        toolId: string;
+        params: Record<string, unknown>;
+    }[];
+}
+interface ListenerEvent {
+    id: string;
+    type: 'file' | 'cron' | 'webhook' | 'manual';
+    source: string;
+    timestamp: string;
+    data: Record<string, unknown>;
+}
+interface ListenerRegistry {
+    fileWatchers: FileWatcherConfig[];
+    cronTriggers: CronTriggerConfig[];
+}
+declare class RainfallListenerRegistry {
+    private rainfall;
+    private context;
+    private executor;
+    private watchers;
+    private cronIntervals;
+    private eventHistory;
+    private maxEventHistory;
+    constructor(rainfall: Rainfall, context: RainfallDaemonContext, executor: RainfallNetworkedExecutor);
+    /**
+     * Register a file watcher
+     * Note: Actual file watching requires fs.watch or chokidar
+     * This is the registry - actual watching is done by the daemon
+     */
+    registerFileWatcher(config: FileWatcherConfig): Promise<void>;
+    /**
+     * Unregister a file watcher
+     */
+    unregisterFileWatcher(id: string): Promise<void>;
+    /**
+     * Register a cron trigger
+     */
+    registerCronTrigger(config: CronTriggerConfig): Promise<void>;
+    /**
+     * Unregister a cron trigger
+     */
+    unregisterCronTrigger(id: string): void;
+    /**
+     * Handle a file event
+     */
+    handleFileEvent(watcherId: string, eventType: 'create' | 'modify' | 'delete', filePath: string): Promise<void>;
+    /**
+     * Handle a cron tick
+     */
+    private handleCronTick;
+    /**
+     * Trigger a manual event (for testing or programmatic triggers)
+     */
+    triggerManual(name: string, data?: Record<string, unknown>): Promise<void>;
+    /**
+     * Get recent events
+     */
+    getRecentEvents(limit?: number): ListenerEvent[];
+    /**
+     * Get active listeners status
+     */
+    getStatus(): {
+        fileWatchers: number;
+        cronTriggers: number;
+        recentEvents: number;
+    };
+    /**
+     * Stop all listeners
+     */
+    stopAll(): Promise<void>;
+    private recordEvent;
+    /**
+     * Simple cron parser - converts basic cron expressions to milliseconds
+     * Supports: @hourly, @daily, @weekly, and simple intervals like every N minutes
+     */
+    private parseCronToMs;
+}
+/**
+ * Create a file watcher workflow helper
+ */
+declare function createFileWatcherWorkflow(name: string, watchPath: string, options: {
+    pattern?: string;
+    events?: ('create' | 'modify' | 'delete')[];
+    workflow: {
+        toolId: string;
+        params: Record<string, unknown>;
+    }[];
+}): FileWatcherConfig;
+/**
+ * Create a cron trigger workflow helper
+ */
+declare function createCronWorkflow(name: string, cron: string, workflow: {
+    toolId: string;
+    params: Record<string, unknown>;
+}[]): CronTriggerConfig;
+
+export { type ContextOptions as C, type FileWatcherConfig as F, type ListenerEvent as L, type MemoryEntry as M, type NetworkedExecutorOptions as N, type QueuedJob as Q, RainfallDaemonContext as R, type SessionContext as S, type ToolExecutionRecord as T, type CronTriggerConfig as a, type ListenerRegistry as b, type NodeCapabilities as c, type NodeRegistration as d, RainfallListenerRegistry as e, RainfallNetworkedExecutor as f, createCronWorkflow as g, createFileWatcherWorkflow as h };