@rainfall-devkit/sdk 0.1.8 → 0.2.1

package/dist/cli/index.mjs

@@ -1,41 +1,21 @@
 #!/usr/bin/env node
+import {
+  createEdgeNodeSecurity
+} from "../chunk-XEQ6U3JQ.mjs";
 import {
   Rainfall
-} from "../chunk-RA3HDYF4.mjs";
+} from "../chunk-VDPKDC3R.mjs";
+import {
+  getConfigDir,
+  loadConfig,
+  saveConfig
+} from "../chunk-NTTAVKRT.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, existsSync, mkdirSync, writeFileSync } 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 +33,72 @@ 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
+  
+  edge generate-keys            Generate key pair for edge node encryption
+  edge status                   Show edge node security status
+  
+  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)
+  --mcp-proxy                   Enable MCP proxy hub (default: enabled)
+  --no-mcp-proxy                Disable MCP proxy hub
+  --secure                      Enable edge node security (JWT, ACLs, encryption)
+  --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) {
@@ -239,16 +263,20 @@ 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") {
@@ -276,6 +304,20 @@ Examples:
         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) {
@@ -313,6 +355,20 @@ Examples:
     }
   }
   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")) {
@@ -339,7 +395,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));
   }
@@ -350,13 +415,306 @@ 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("  custom    - Use any custom OpenAI-compatible endpoint (RunPod, 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 custom");
+  console.log("  rainfall config set llm.baseUrl https://your-runpod-endpoint.runpod.net/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;
+  let enableMcpProxy = true;
+  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;
+    } else if (arg === "--mcp-proxy") {
+      enableMcpProxy = true;
+    } else if (arg === "--no-mcp-proxy") {
+      enableMcpProxy = false;
+    }
+  }
+  const { startDaemon } = await import("../daemon/index.mjs");
+  try {
+    await startDaemon({ port, openaiPort, debug, enableMcpProxy });
+    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(`  MCP clients: ${status.mcpClients || 0}`);
+  console.log(`  MCP tools: ${status.mcpTools || 0}`);
+  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 edgeGenerateKeys() {
+  console.log("\u{1F510} Generating edge node key pair...\n");
+  try {
+    const security = await createEdgeNodeSecurity();
+    const keyPair = await security.generateKeyPair();
+    const configDir = getConfigDir();
+    const keysDir = join(configDir, "keys");
+    if (!existsSync(keysDir)) {
+      mkdirSync(keysDir, { recursive: true });
+    }
+    const publicKeyPath = join(keysDir, "edge-node.pub");
+    const privateKeyPath = join(keysDir, "edge-node.key");
+    writeFileSync(publicKeyPath, keyPair.publicKey, { mode: 420 });
+    writeFileSync(privateKeyPath, keyPair.privateKey, { mode: 384 });
+    console.log("\u2705 Key pair generated successfully!\n");
+    console.log("Public key:", keyPair.publicKey);
+    console.log("\nKey files saved to:");
+    console.log("  Public:", publicKeyPath);
+    console.log("  Private:", privateKeyPath);
+    console.log("\n\u{1F4CB} To register this edge node:");
+    console.log("  1. Copy the public key above");
+    console.log("  2. Register with: rainfall edge register <public-key>");
+    console.log("  3. The backend will return an edgeNodeSecret (JWT)");
+    console.log("  4. Store the secret securely - it expires in 30 days");
+  } catch (error) {
+    console.error("\u274C Failed to generate keys:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function edgeStatus() {
+  const configDir = getConfigDir();
+  const keysDir = join(configDir, "keys");
+  const publicKeyPath = join(keysDir, "edge-node.pub");
+  const privateKeyPath = join(keysDir, "edge-node.key");
+  console.log("\u{1F510} Edge Node Security Status\n");
+  const hasPublicKey = existsSync(publicKeyPath);
+  const hasPrivateKey = existsSync(privateKeyPath);
+  console.log("Key Pair:");
+  console.log("  Public key:", hasPublicKey ? "\u2705 Present" : "\u274C Missing");
+  console.log("  Private key:", hasPrivateKey ? "\u2705 Present" : "\u274C Missing");
+  if (hasPublicKey) {
+    const publicKey = readFileSync(publicKeyPath, "utf-8");
+    console.log("\nPublic Key:");
+    console.log("  " + publicKey.substring(0, 50) + "...");
+  }
+  const config = loadConfig();
+  if (config.edgeNodeId) {
+    console.log("\nRegistration:");
+    console.log("  Edge Node ID:", config.edgeNodeId);
+  }
+  if (config.edgeNodeSecret) {
+    console.log("  JWT Secret: \u2705 Present (expires: check with backend)");
+  } else {
+    console.log("  JWT Secret: \u274C Not configured");
+  }
+  console.log("\n\u{1F4DA} Next steps:");
+  if (!hasPublicKey) {
+    console.log("  1. Run: rainfall edge generate-keys");
+  } else if (!config.edgeNodeSecret) {
+    console.log("  1. Register your edge node with the backend");
+    console.log("  2. Store the returned edgeNodeSecret in config");
+  } else {
+    console.log("  Edge node is configured and ready for secure operation");
+  }
+}
 async function main() {
   const args = process.argv.slice(2);
   const command = args[0];
@@ -400,6 +758,40 @@ async function main() {
     case "run":
       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();
       break;
@@ -411,9 +803,34 @@ 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 "edge":
+      switch (subcommand) {
+        case "generate-keys":
+          await edgeGenerateKeys();
+          break;
+        case "status":
+          await edgeStatus();
+          break;
+        default:
+          console.error("Error: Unknown edge subcommand");
+          console.error("\nUsage: rainfall edge <generate-keys|status>");
           process.exit(1);
       }
       break;

package/dist/config-7UT7GYSN.mjs

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

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-MD45VGWD.mjs

@@ -0,0 +1,14 @@
+import {
+  getLLMConfig,
+  getProviderBaseUrl,
+  isLocalProvider,
+  loadConfig,
+  saveConfig
+} from "./chunk-EI7SJH5K.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
+};