@rainfall-devkit/sdk 0.1.7 → 0.2.0

package/dist/cli/index.mjs

@@ -1,41 +1,17 @@
 #!/usr/bin/env node
 import {
   Rainfall
-} from "../chunk-PNYIIMJS.mjs";
+} from "../chunk-VDPKDC3R.mjs";
+import {
+  loadConfig,
+  saveConfig
+} from "../chunk-WOITG5TG.mjs";
 
 // src/cli/index.ts
-import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-var CONFIG_DIR = join(homedir(), ".rainfall");
-var CONFIG_FILE = join(CONFIG_DIR, "config.json");
-function loadConfig() {
-  if (!existsSync(CONFIG_FILE)) {
-    return {};
-  }
-  try {
-    return JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function saveConfig(config) {
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-function getRainfall() {
-  const config = loadConfig();
-  if (!config.apiKey) {
-    console.error("Error: No API key configured. Run: rainfall auth login");
-    process.exit(1);
-  }
-  return new Rainfall({
-    apiKey: config.apiKey,
-    baseUrl: config.baseUrl
-  });
-}
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { spawn } from "child_process";
 function printHelp() {
   console.log(`
 Rainfall CLI - 200+ tools, one key
@@ -53,28 +29,66 @@ Commands:
   tools search <query>          Search for tools
   
   run <tool> [options]          Execute a tool
+
+  daemon start                  Start the Rainfall daemon
+  daemon stop                   Stop the Rainfall daemon
+  daemon restart                Restart the Rainfall daemon
+  daemon status                 Check daemon status
+  
+  workflow new                  Create a new workflow (interactive)
+  workflow run <workflow>       Run a saved workflow
   
   me                            Show account info and usage
   
   config get [key]              Get configuration value
   config set <key> <value>      Set configuration value
+  config llm                    Show LLM configuration
+  
+  version                       Show version information
+  upgrade                       Upgrade to the latest version
   
   help                          Show this help message
 
+Configuration keys:
+  llm.provider                  LLM provider (rainfall|openai|anthropic|ollama|local)
+  llm.baseUrl                   Base URL for the LLM API
+  llm.apiKey                    API key for the LLM provider
+  llm.model                     Default model to use
+
 Options for 'run':
   --params, -p <json>           Tool parameters as JSON
   --file, -f <path>             Read parameters from file
   --raw                         Output raw JSON
+  --<key> <value>               Pass individual parameters (e.g., --query "AI news")
+
+Options for 'daemon start':
+  --port <port>                 WebSocket port (default: 8765)
+  --openai-port <port>          OpenAI API port (default: 8787)
+  --debug                       Enable verbose debug logging
 
 Examples:
   rainfall auth login
   rainfall tools list
   rainfall tools describe github-create-issue
   rainfall run exa-web-search -p '{"query": "AI news"}'
+  rainfall run exa-web-search --query "AI news"
+  rainfall run github-create-issue --owner facebook --repo react --title "Bug"
   rainfall run article-summarize -f ./article.json
+  rainfall daemon start
   echo '{"query": "hello"}' | rainfall run exa-web-search
 `);
 }
+function getRainfall() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    console.error("Error: No API key configured. Run: rainfall auth login");
+    process.exit(1);
+  }
+  return new Rainfall({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
 async function authLogin(args) {
   const apiKey = args[0] || process.env.RAINFALL_API_KEY;
   if (!apiKey) {
@@ -229,7 +243,30 @@ async function runTool(args) {
     console.error("\nUsage: rainfall run <tool-id> [options]");
     process.exit(1);
   }
+  if (toolId === "--help" || toolId === "-h") {
+    console.log(`
+Usage: rainfall run <tool-id> [options]
+
+Execute a tool by ID.
+
+Options:
+  -p, --params <json>    Tool parameters as JSON string
+  -f, --file <path>      Read parameters from JSON file
+  --raw                  Output raw JSON (no formatting)
+  --<key> <value>        Pass individual parameters (e.g., --query "AI news")
+
+Examples:
+  rainfall run figma-users-getMe
+  rainfall run exa-web-search -p '{"query": "AI news"}'
+  rainfall run exa-web-search --query "AI news"
+  rainfall run github-create-issue --owner facebook --repo react --title "Bug"
+  rainfall run github-create-issue -f ./issue.json
+  echo '{"query": "hello"}' | rainfall run exa-web-search
+`);
+    return;
+  }
   let params = {};
+  const rawArgs = [];
   for (let i = 1; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--params" || arg === "-p") {
@@ -257,22 +294,71 @@ async function runTool(args) {
         process.exit(1);
       }
     } else if (arg === "--raw") {
+    } else if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const value = args[++i];
+      if (value === void 0) {
+        console.error(`Error: ${arg} requires a value`);
+        process.exit(1);
+      }
+      try {
+        params[key] = JSON.parse(value);
+      } catch {
+        params[key] = value;
+      }
+    } else {
+      rawArgs.push(arg);
     }
   }
   if (!process.stdin.isTTY) {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(chunk);
-    }
-    if (chunks.length > 0) {
-      try {
-        const piped = JSON.parse(Buffer.concat(chunks).toString());
-        params = { ...params, ...piped };
-      } catch {
+    process.stdin.pause();
+    const fs = await import("fs");
+    try {
+      const buffer = Buffer.alloc(1024);
+      const bytesRead = await new Promise((resolve) => {
+        const timeout = setTimeout(() => resolve(0), 50);
+        fs.read(process.stdin.fd, buffer, 0, 1024, null, (err, n) => {
+          clearTimeout(timeout);
+          resolve(err ? 0 : n);
+        });
+      });
+      if (bytesRead > 0) {
+        let data = buffer.toString("utf8", 0, bytesRead);
+        while (true) {
+          const more = await new Promise((resolve) => {
+            fs.read(process.stdin.fd, buffer, 0, 1024, null, (err, n) => {
+              resolve(err ? 0 : n);
+            });
+          });
+          if (more === 0) break;
+          data += buffer.toString("utf8", 0, more);
+        }
+        if (data.trim()) {
+          try {
+            const piped = JSON.parse(data);
+            params = { ...params, ...piped };
+          } catch {
+          }
+        }
       }
+    } catch {
     }
   }
   const rainfall = getRainfall();
+  if (rawArgs.length === 1 && Object.keys(params).length === 0) {
+    try {
+      const schema = await rainfall.getToolSchema(toolId);
+      if (schema.parameters && typeof schema.parameters === "object") {
+        const paramEntries = Object.entries(schema.parameters);
+        const requiredParams = paramEntries.filter(([, p]) => !p.optional);
+        if (requiredParams.length === 1) {
+          const [paramName] = requiredParams[0];
+          params = { [paramName]: rawArgs[0] };
+        }
+      }
+    } catch {
+    }
+  }
   try {
     const result = await rainfall.executeTool(toolId, params);
     if (args.includes("--raw")) {
@@ -299,7 +385,16 @@ function configGet(args) {
   const key = args[0];
   const config = loadConfig();
   if (key) {
-    console.log(config[key] || "");
+    const parts = key.split(".");
+    let value = config;
+    for (const part of parts) {
+      value = value?.[part];
+    }
+    if (typeof value === "object" && value !== null) {
+      console.log(JSON.stringify(value, null, 2));
+    } else {
+      console.log(value ?? "");
+    }
   } else {
     console.log(JSON.stringify(config, null, 2));
   }
@@ -310,13 +405,231 @@ function configSet(args) {
   if (!key || !value) {
     console.error("Error: Both key and value required");
     console.error("\nUsage: rainfall config set <key> <value>");
+    console.error("\nExamples:");
+    console.error("  rainfall config set llm.provider local");
+    console.error("  rainfall config set llm.baseUrl http://localhost:1234/v1");
+    console.error("  rainfall config set llm.model llama-3.3-70b-versatile");
     process.exit(1);
   }
   const config = loadConfig();
-  config[key] = value;
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    config[key] = value;
+  } else {
+    let target = config;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!target[parts[i]] || typeof target[parts[i]] !== "object") {
+        target[parts[i]] = {};
+      }
+      target = target[parts[i]];
+    }
+    target[parts[parts.length - 1]] = value;
+  }
   saveConfig(config);
   console.log(`\u2713 Set ${key} = ${value}`);
 }
+function configLLM() {
+  const config = loadConfig();
+  const llm = config.llm || { provider: "rainfall" };
+  console.log("LLM Configuration:");
+  console.log(`  Provider: ${llm.provider}`);
+  console.log(`  Base URL: ${llm.baseUrl || "(default)"}`);
+  console.log(`  Model: ${llm.model || "(default)"}`);
+  console.log(`  API Key: ${llm.apiKey ? "****" + llm.apiKey.slice(-4) : "(none)"}`);
+  console.log();
+  console.log("Providers:");
+  console.log("  rainfall  - Use Rainfall backend (default, uses your credits)");
+  console.log("  openai    - Use OpenAI API directly");
+  console.log("  anthropic - Use Anthropic API directly");
+  console.log("  ollama    - Use local Ollama instance");
+  console.log("  local     - Use any OpenAI-compatible endpoint (LM Studio, etc.)");
+  console.log();
+  console.log("Examples:");
+  console.log("  rainfall config set llm.provider local");
+  console.log("  rainfall config set llm.baseUrl http://localhost:1234/v1");
+  console.log("  rainfall config set llm.provider openai");
+  console.log("  rainfall config set llm.apiKey sk-...");
+}
+function getPackageJson() {
+  try {
+    const __filename2 = fileURLToPath(import.meta.url);
+    const __dirname2 = dirname(__filename2);
+    const packagePath = join(__dirname2, "..", "..", "package.json");
+    const content = readFileSync(packagePath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { version: "unknown", name: "@rainfall-devkit/sdk" };
+  }
+}
+function showVersion() {
+  const pkg = getPackageJson();
+  console.log(`${pkg.name} v${pkg.version}`);
+}
+async function upgrade() {
+  const pkg = getPackageJson();
+  console.log(`Upgrading ${pkg.name}...`);
+  const execPath = process.argv[0];
+  const isBun = execPath.includes("bun");
+  let command;
+  let args;
+  if (isBun) {
+    command = "bun";
+    args = ["add", "-g", `${pkg.name}@latest`];
+  } else {
+    command = "npm";
+    args = ["i", "-g", `${pkg.name}@latest`];
+  }
+  console.log(`Running: ${command} ${args.join(" ")}`);
+  console.log();
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        console.log();
+        console.log("\u2713 Upgrade complete");
+        resolve();
+      } else {
+        reject(new Error(`Upgrade failed with exit code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function daemonStart(args) {
+  let port;
+  let openaiPort;
+  let debug = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) port = val;
+    } else if (arg === "--openai-port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) openaiPort = val;
+    } else if (arg === "--debug") {
+      debug = true;
+    }
+  }
+  const { startDaemon } = await import("../daemon/index.mjs");
+  try {
+    await startDaemon({ port, openaiPort, debug });
+    process.on("SIGINT", async () => {
+      console.log("\n");
+      const { stopDaemon } = await import("../daemon/index.mjs");
+      await stopDaemon();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      const { stopDaemon } = await import("../daemon/index.mjs");
+      await stopDaemon();
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("Failed to start daemon:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function daemonStop() {
+  const { stopDaemon } = await import("../daemon/index.mjs");
+  await stopDaemon();
+}
+async function daemonRestart(args) {
+  const { stopDaemon, startDaemon } = await import("../daemon/index.mjs");
+  let port;
+  let openaiPort;
+  let debug = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) port = val;
+    } else if (arg === "--openai-port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) openaiPort = val;
+    } else if (arg === "--debug") {
+      debug = true;
+    }
+  }
+  console.log("\u{1F504} Restarting daemon...");
+  try {
+    await stopDaemon();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    await startDaemon({ port, openaiPort, debug });
+    process.on("SIGINT", async () => {
+      console.log("\n");
+      const { stopDaemon: stop } = await import("../daemon/index.mjs");
+      await stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      const { stopDaemon: stop } = await import("../daemon/index.mjs");
+      await stop();
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("Failed to restart daemon:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function daemonStatus() {
+  const { getDaemonStatus } = await import("../daemon/index.mjs");
+  const status = getDaemonStatus();
+  if (!status) {
+    console.log("Daemon not running");
+    console.log("Run: rainfall daemon start");
+    return;
+  }
+  console.log("Daemon status:");
+  console.log(`  Running: ${status.running ? "yes" : "no"}`);
+  console.log(`  WebSocket port: ${status.port}`);
+  console.log(`  OpenAI API port: ${status.openaiPort}`);
+  console.log(`  Tools loaded: ${status.toolsLoaded}`);
+  console.log(`  Clients connected: ${status.clientsConnected}`);
+  console.log(`  Edge Node ID: ${status.edgeNodeId || "local"}`);
+  console.log();
+  console.log("Context:");
+  console.log(`  Memories cached: ${status.context.memoriesCached}`);
+  console.log(`  Active sessions: ${status.context.activeSessions}`);
+  console.log(`  Current session: ${status.context.currentSession || "none"}`);
+  console.log(`  Execution history: ${status.context.executionHistorySize}`);
+  console.log();
+  console.log("Listeners:");
+  console.log(`  File watchers: ${status.listeners.fileWatchers}`);
+  console.log(`  Cron triggers: ${status.listeners.cronTriggers}`);
+  console.log(`  Recent events: ${status.listeners.recentEvents}`);
+}
+async function workflowNew() {
+  console.log("\u{1F6A7} Interactive workflow creation coming soon!");
+  console.log();
+  console.log("For now, create workflows using the SDK:");
+  console.log('  import { createFileWatcherWorkflow } from "@rainfall-devkit/sdk/daemon";');
+  console.log();
+  console.log("Example:");
+  console.log(`  const workflow = createFileWatcherWorkflow('pdf-processor', '~/Downloads', {`);
+  console.log(`    pattern: '*.pdf',`);
+  console.log(`    events: ['create'],`);
+  console.log(`    workflow: [`);
+  console.log(`      { toolId: 'ocr-pdf', params: {} },`);
+  console.log(`      { toolId: 'notion-create-page', params: { parent: '...' } },`);
+  console.log(`    ],`);
+  console.log(`  });`);
+}
+async function workflowRun(args) {
+  const workflowId = args[0];
+  if (!workflowId) {
+    console.error("Error: Workflow ID required");
+    console.error("\nUsage: rainfall workflow run <workflow-id>");
+    process.exit(1);
+  }
+  console.log(`\u{1F6A7} Running workflow: ${workflowId}`);
+  console.log("Workflow execution coming soon!");
+}
 async function main() {
   const args = process.argv.slice(2);
   const command = args[0];
@@ -358,7 +671,41 @@ async function main() {
       }
       break;
     case "run":
-      await runTool(rest);
+      await runTool(args.slice(1));
+      break;
+    case "daemon":
+      switch (subcommand) {
+        case "start":
+          await daemonStart(rest);
+          break;
+        case "stop":
+          await daemonStop();
+          break;
+        case "restart":
+          await daemonRestart(rest);
+          break;
+        case "status":
+          await daemonStatus();
+          break;
+        default:
+          console.error("Error: Unknown daemon subcommand");
+          console.error("\nUsage: rainfall daemon <start|stop|restart|status>");
+          process.exit(1);
+      }
+      break;
+    case "workflow":
+      switch (subcommand) {
+        case "new":
+          await workflowNew();
+          break;
+        case "run":
+          await workflowRun(rest);
+          break;
+        default:
+          console.error("Error: Unknown workflow subcommand");
+          console.error("\nUsage: rainfall workflow <new|run>");
+          process.exit(1);
+      }
       break;
     case "me":
       await showMe();
@@ -371,12 +718,23 @@ async function main() {
         case "set":
           configSet(rest);
           break;
+        case "llm":
+          configLLM();
+          break;
         default:
           console.error("Error: Unknown config subcommand");
-          console.error("\nUsage: rainfall config <get|set>");
+          console.error("\nUsage: rainfall config <get|set|llm>");
           process.exit(1);
       }
       break;
+    case "version":
+    case "--version":
+    case "-v":
+      showVersion();
+      break;
+    case "upgrade":
+      await upgrade();
+      break;
     case "help":
     case "--help":
     case "-h":

package/dist/config-DDTQQBN7.mjs

@@ -0,0 +1,14 @@
+import {
+  getLLMConfig,
+  getProviderBaseUrl,
+  isLocalProvider,
+  loadConfig,
+  saveConfig
+} from "./chunk-WOITG5TG.mjs";
+export {
+  getLLMConfig,
+  getProviderBaseUrl,
+  isLocalProvider,
+  loadConfig,
+  saveConfig
+};

package/dist/config-ZKNHII2A.mjs

@@ -0,0 +1,8 @@
+import {
+  loadConfig,
+  saveConfig
+} from "./chunk-AQFC7YAX.mjs";
+export {
+  loadConfig,
+  saveConfig
+};

package/dist/daemon/index.d.mts

@@ -0,0 +1,136 @@
+import { e as RainfallConfig } from '../sdk-DD1OeGRJ.mjs';
+import { N as NetworkedExecutorOptions, C as ContextOptions, e as RainfallNetworkedExecutor, R as RainfallDaemonContext, d as RainfallListenerRegistry } from '../listeners-CYI-YwIF.mjs';
+
+/**
+ * Rainfall Daemon - Local websocket server + OpenAI-compatible proxy
+ *
+ * Provides:
+ * - WebSocket server for MCP clients (Claude, Cursor, etc.)
+ * - OpenAI-compatible /v1/chat/completions endpoint
+ * - Hot-loaded tools from Rainfall SDK
+ * - Networked execution for distributed workflows
+ * - Persistent context and memory
+ * - Passive listeners (file watchers, cron triggers)
+ */
+
+interface DaemonConfig {
+    port?: number;
+    openaiPort?: number;
+    rainfallConfig?: RainfallConfig;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Networked executor options */
+    networkedOptions?: NetworkedExecutorOptions;
+    /** Context/memory options */
+    contextOptions?: ContextOptions;
+}
+interface DaemonStatus {
+    running: boolean;
+    port?: number;
+    openaiPort?: number;
+    toolsLoaded: number;
+    clientsConnected: number;
+    edgeNodeId?: string;
+    context: {
+        memoriesCached: number;
+        activeSessions: number;
+        currentSession?: string;
+        executionHistorySize: number;
+    };
+    listeners: {
+        fileWatchers: number;
+        cronTriggers: number;
+        recentEvents: number;
+    };
+}
+declare class RainfallDaemon {
+    private wss?;
+    private openaiApp;
+    private rainfall?;
+    private port;
+    private openaiPort;
+    private rainfallConfig?;
+    private tools;
+    private toolSchemas;
+    private clients;
+    private debug;
+    private networkedExecutor?;
+    private context?;
+    private listeners?;
+    constructor(config?: DaemonConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Get the networked executor for distributed job management
+     */
+    getNetworkedExecutor(): RainfallNetworkedExecutor | undefined;
+    /**
+     * Get the context for memory/session management
+     */
+    getContext(): RainfallDaemonContext | undefined;
+    /**
+     * Get the listener registry for passive triggers
+     */
+    getListenerRegistry(): RainfallListenerRegistry | undefined;
+    private initializeRainfall;
+    private loadTools;
+    private getToolSchema;
+    private startWebSocketServer;
+    private handleMCPMessage;
+    private getMCPTools;
+    private executeTool;
+    private startOpenAIProxy;
+    /**
+     * Build a map of local Rainfall tools for quick lookup
+     * Maps OpenAI-style underscore names to Rainfall tool IDs
+     */
+    private buildLocalToolMap;
+    /**
+     * Find a local Rainfall tool by name (OpenAI underscore format or original)
+     */
+    private findLocalTool;
+    /**
+     * Execute a local Rainfall tool
+     */
+    private executeLocalTool;
+    /**
+     * Parse XML-style tool calls from model output
+     * Handles formats like: <function=name><parameter=key>value</parameter></function>
+     */
+    private parseXMLToolCalls;
+    /**
+     * Call the LLM via Rainfall backend, LM Studio, RunPod, or other providers
+     *
+     * Provider priority:
+     * 1. Config file (llm.provider, llm.baseUrl)
+     * 2. Environment variables (OPENAI_API_KEY, OLLAMA_HOST, etc.)
+     * 3. Default to Rainfall (credits-based)
+     */
+    private callLLM;
+    /**
+     * Call external LLM provider (OpenAI, Anthropic) via their OpenAI-compatible APIs
+     */
+    private callExternalLLM;
+    /**
+     * Call a local LLM (LM Studio, Ollama, etc.)
+     */
+    private callLocalLLM;
+    /**
+     * Stream a response to the client (converts non-streaming to SSE format)
+     */
+    private streamResponse;
+    /**
+     * Update context with conversation history
+     */
+    private updateContext;
+    private getOpenAITools;
+    private buildResponseContent;
+    getStatus(): DaemonStatus;
+    private log;
+}
+declare function startDaemon(config?: DaemonConfig): Promise<RainfallDaemon>;
+declare function stopDaemon(): Promise<void>;
+declare function getDaemonStatus(): DaemonStatus | null;
+declare function getDaemonInstance(): RainfallDaemon | null;
+
+export { type DaemonConfig, type DaemonStatus, RainfallDaemon, getDaemonInstance, getDaemonStatus, startDaemon, stopDaemon };