@rainfall-devkit/sdk 0.1.8 → 0.2.1

package/dist/index.mjs

@@ -1,3 +1,14 @@
+import {
+  EdgeNodeSecurity,
+  createEdgeNodeSecurity
+} from "./chunk-XEQ6U3JQ.mjs";
+import {
+  RainfallDaemonContext,
+  RainfallListenerRegistry,
+  RainfallNetworkedExecutor,
+  createCronWorkflow,
+  createFileWatcherWorkflow
+} from "./chunk-7MRE4ZVI.mjs";
 import {
   AuthenticationError,
   NetworkError,
@@ -10,21 +21,235 @@ import {
   TimeoutError,
   ToolNotFoundError,
   ValidationError
-} from "./chunk-RA3HDYF4.mjs";
+} from "./chunk-VDPKDC3R.mjs";
+
+// src/security/edge-client.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+var SecureEdgeClient = class {
+  client;
+  security;
+  edgeNodeId;
+  edgeNodeSecret;
+  keysPath;
+  jwtPayload;
+  keyPair;
+  constructor(config) {
+    this.client = config.client;
+    this.edgeNodeId = config.edgeNodeId;
+    this.edgeNodeSecret = config.edgeNodeSecret;
+    this.keysPath = config.keysPath;
+    this.security = new EdgeNodeSecurity({
+      backendSecret: config.backendSecret
+    });
+  }
+  /**
+   * Initialize the secure client
+   */
+  async initialize() {
+    await this.security.initialize();
+    await this.loadKeyPair();
+    this.jwtPayload = this.security.validateJWT(this.edgeNodeSecret);
+    if (this.jwtPayload.edgeNodeId !== this.edgeNodeId) {
+      throw new Error("JWT edge node ID mismatch");
+    }
+  }
+  /**
+   * Load key pair from disk
+   */
+  async loadKeyPair() {
+    const publicKeyPath = join(this.keysPath, "edge-node.pub");
+    const privateKeyPath = join(this.keysPath, "edge-node.key");
+    if (!existsSync(publicKeyPath) || !existsSync(privateKeyPath)) {
+      throw new Error("Key pair not found. Run: rainfall edge generate-keys");
+    }
+    this.keyPair = {
+      publicKey: readFileSync(publicKeyPath, "utf-8"),
+      privateKey: readFileSync(privateKeyPath, "utf-8")
+    };
+  }
+  /**
+   * Get public key for sharing with backend
+   */
+  getPublicKey() {
+    if (!this.keyPair) {
+      throw new Error("Key pair not loaded");
+    }
+    return this.keyPair.publicKey;
+  }
+  /**
+   * Send heartbeat with authentication
+   */
+  async heartbeat() {
+    this.requireAuth();
+    return this.client.request("/edge/heartbeat", {
+      method: "POST",
+      body: {
+        edgeNodeId: this.edgeNodeId,
+        timestamp: Date.now()
+      },
+      headers: {
+        "Authorization": `Bearer ${this.edgeNodeSecret}`
+      }
+    });
+  }
+  /**
+   * Claim a job from the queue
+   */
+  async claimJob() {
+    this.requireAuth();
+    const job = await this.client.request("/edge/claim-job", {
+      method: "POST",
+      body: {
+        edgeNodeId: this.edgeNodeId,
+        subscriberId: this.jwtPayload.subscriberId
+      },
+      headers: {
+        "Authorization": `Bearer ${this.edgeNodeSecret}`
+      }
+    });
+    if (job && job.encrypted && job.params) {
+      const decrypted = await this.decryptJobParams(job.params);
+      return { ...job, params: decrypted };
+    }
+    return job;
+  }
+  /**
+   * Submit job result
+   */
+  async submitJobResult(result) {
+    this.requireAuth();
+    let encryptedOutput;
+    if (result.output) {
+      encryptedOutput = await this.encryptJobResult(result.output);
+    }
+    await this.client.request("/edge/submit-job-result", {
+      method: "POST",
+      body: {
+        edgeNodeId: this.edgeNodeId,
+        subscriberId: this.jwtPayload.subscriberId,
+        result: {
+          ...result,
+          output: encryptedOutput,
+          encrypted: !!encryptedOutput
+        }
+      },
+      headers: {
+        "Authorization": `Bearer ${this.edgeNodeSecret}`
+      }
+    });
+  }
+  /**
+   * Queue a job for processing
+   */
+  async queueJob(type, params, targetPublicKey) {
+    this.requireAuth();
+    let encryptedParams;
+    let encrypted = false;
+    if (targetPublicKey) {
+      encryptedParams = await this.encryptJobParamsForTarget(
+        JSON.stringify(params),
+        targetPublicKey
+      );
+      encrypted = true;
+    }
+    return this.client.request("/edge/queue-job", {
+      method: "POST",
+      body: {
+        edgeNodeId: this.edgeNodeId,
+        subscriberId: this.jwtPayload.subscriberId,
+        job: {
+          type,
+          params: encryptedParams || JSON.stringify(params),
+          encrypted
+        }
+      },
+      headers: {
+        "Authorization": `Bearer ${this.edgeNodeSecret}`
+      }
+    });
+  }
+  /**
+   * Decrypt job params received from backend
+   */
+  async decryptJobParams(encryptedParams) {
+    const encrypted = JSON.parse(encryptedParams);
+    return this.security.decryptFromBackend(encrypted);
+  }
+  /**
+   * Encrypt job result for sending to backend
+   */
+  async encryptJobResult(output) {
+    const encrypted = await this.security.encryptLocal(output, this.keyPair.privateKey);
+    return JSON.stringify(encrypted);
+  }
+  /**
+   * Encrypt job params for a specific target edge node
+   */
+  async encryptJobParamsForTarget(params, targetPublicKey) {
+    const encrypted = await this.security.encryptForEdgeNode(params, targetPublicKey);
+    return JSON.stringify(encrypted);
+  }
+  /**
+   * Check if client is authenticated
+   */
+  requireAuth() {
+    if (!this.jwtPayload) {
+      throw new Error("Client not authenticated. Call initialize() first.");
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (this.jwtPayload.expiresAt < now) {
+      throw new Error("JWT token expired. Re-register edge node.");
+    }
+  }
+  /**
+   * Get current authentication status
+   */
+  getAuthStatus() {
+    if (!this.jwtPayload) {
+      return { authenticated: false };
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    return {
+      authenticated: this.jwtPayload.expiresAt > now,
+      edgeNodeId: this.jwtPayload.edgeNodeId,
+      subscriberId: this.jwtPayload.subscriberId,
+      expiresAt: this.jwtPayload.expiresAt,
+      scopes: this.jwtPayload.scopes
+    };
+  }
+};
+async function createSecureEdgeClient(client, options) {
+  const secureClient = new SecureEdgeClient({
+    client,
+    ...options
+  });
+  await secureClient.initialize();
+  return secureClient;
+}
 
 // src/index.ts
 var VERSION = "0.1.0";
 export {
   AuthenticationError,
+  EdgeNodeSecurity,
   NetworkError,
   NotFoundError,
   Rainfall,
   RainfallClient,
+  RainfallDaemonContext,
   RainfallError,
+  RainfallListenerRegistry,
+  RainfallNetworkedExecutor,
   RateLimitError,
+  SecureEdgeClient,
   ServerError,
   TimeoutError,
   ToolNotFoundError,
   VERSION,
-  ValidationError
+  ValidationError,
+  createCronWorkflow,
+  createEdgeNodeSecurity,
+  createFileWatcherWorkflow,
+  createSecureEdgeClient
 };

package/dist/listeners-B5Vy9Ao5.d.ts

@@ -0,0 +1,372 @@
+import { a as Rainfall } from './sdk-4OvXPr8E.js';
+
+/**
+ * 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 EdgeNodeRegistration {
+    edgeNodeId: 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';
+    requesterEdgeNodeId?: string;
+    executorEdgeNodeId?: 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;
+    /** Edge node capabilities */
+    capabilities?: NodeCapabilities;
+    /** Hostname identifier */
+    hostname?: string;
+}
+declare class RainfallNetworkedExecutor {
+    private rainfall;
+    private options;
+    private edgeNodeId?;
+    private jobCallbacks;
+    private resultPollingInterval?;
+    constructor(rainfall: Rainfall, options?: NetworkedExecutorOptions);
+    /**
+     * Register this edge node with the Rainfall backend
+     */
+    registerEdgeNode(): Promise<string>;
+    /**
+     * Unregister this edge node on shutdown
+     */
+    unregisterEdgeNode(): 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 edge node
+     */
+    claimJob(): Promise<QueuedJob | null>;
+    /**
+     * Submit job result after execution
+     */
+    submitJobResult(jobId: string, result: unknown, error?: string): Promise<void>;
+    /**
+     * Get this edge node's ID
+     */
+    getEdgeNodeId(): 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;
+    edgeNodeId?: 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;
+        edgeNodeId?: 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 EdgeNodeRegistration as E, type FileWatcherConfig as F, type ListenerEvent as L, type MemoryEntry as M, type NetworkedExecutorOptions as N, type QueuedJob as Q, RainfallNetworkedExecutor as R, type SessionContext as S, type ToolExecutionRecord as T, RainfallDaemonContext as a, RainfallListenerRegistry as b, type CronTriggerConfig as c, type ListenerRegistry as d, type NodeCapabilities as e, createCronWorkflow as f, createFileWatcherWorkflow as g };