@rainfall-devkit/sdk 0.2.2 → 0.2.4

package/dist/cli/index.mjs

@@ -1,10 +1,15 @@
 #!/usr/bin/env node
 import {
-  createEdgeNodeSecurity
-} from "../chunk-NCQVOLS4.mjs";
+  createEdgeNodeSecurity,
+  globalHandlerRegistry
+} from "../chunk-6FXRLPLR.mjs";
 import {
   Rainfall
-} from "../chunk-VDPKDC3R.mjs";
+} from "../chunk-2FYYTIJQ.mjs";
+import "../chunk-LJQEO3CY.mjs";
+import {
+  formatResult
+} from "../chunk-XHPFY5MH.mjs";
 import {
   getConfigDir,
   loadConfig,
@@ -49,6 +54,7 @@ Commands:
   config llm                    Show LLM configuration
   
   edge generate-keys            Generate key pair for edge node encryption
+  edge register <proc-node-id>  Register a proc node for edge execution
   edge status                   Show edge node security status
   
   version                       Show version information
@@ -66,7 +72,12 @@ Options for 'run':
   --params, -p <json>           Tool parameters as JSON
   --file, -f <path>             Read parameters from file
   --raw                         Output raw JSON
+  --table                       Output as table (if applicable)
+  --terminal                    Output for terminal consumption (minimal formatting)
   --<key> <value>               Pass individual parameters (e.g., --query "AI news")
+                                Arrays: --tickers AAPL,GOOGL (comma-separated)
+                                Numbers: --count 42
+                                Booleans: --enabled true
 
 Options for 'daemon start':
   --port <port>                 WebSocket port (default: 8765)
@@ -82,6 +93,7 @@ Examples:
   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 finviz-quotes --tickers AAPL,GOOGL,MSFT
   rainfall run github-create-issue --owner facebook --repo react --title "Bug"
   rainfall run article-summarize -f ./article.json
   rainfall daemon start
@@ -99,6 +111,24 @@ function getRainfall() {
     baseUrl: config.baseUrl
   });
 }
+async function fetchAllNodeIds(rainfall) {
+  try {
+    const client = rainfall.getClient();
+    const subscriberId = await client.ensureSubscriberId();
+    const result = await client.request(
+      `/olympic/subscribers/${subscriberId}/nodes/_utils/node-list`
+    );
+    if (result.keys && Array.isArray(result.keys)) {
+      return result.keys;
+    }
+    if (result.nodes && Array.isArray(result.nodes)) {
+      return result.nodes.map((n) => n.id);
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
 async function authLogin(args) {
   const apiKey = args[0] || process.env.RAINFALL_API_KEY;
   if (!apiKey) {
@@ -185,6 +215,100 @@ function formatSchema(obj, indent = 0) {
   }
   return lines.join("\n");
 }
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function jaroWinklerSimilarity(a, b) {
+  if (a === b) return 1;
+  if (a.length === 0 || b.length === 0) return 0;
+  const matchDistance = Math.floor(Math.max(a.length, b.length) / 2) - 1;
+  const aMatches = new Array(a.length).fill(false);
+  const bMatches = new Array(b.length).fill(false);
+  let matches = 0;
+  let transpositions = 0;
+  for (let i = 0; i < a.length; i++) {
+    const start = Math.max(0, i - matchDistance);
+    const end = Math.min(i + matchDistance + 1, b.length);
+    for (let j = start; j < end; j++) {
+      if (bMatches[j] || a.charAt(i) !== b.charAt(j)) continue;
+      aMatches[i] = true;
+      bMatches[j] = true;
+      matches++;
+      break;
+    }
+  }
+  if (matches === 0) return 0;
+  let k = 0;
+  for (let i = 0; i < a.length; i++) {
+    if (!aMatches[i]) continue;
+    while (!bMatches[k]) k++;
+    if (a.charAt(i) !== b.charAt(k)) transpositions++;
+    k++;
+  }
+  const jaro = (matches / a.length + matches / b.length + (matches - transpositions / 2) / matches) / 3;
+  let prefixLength = 0;
+  for (let i = 0; i < Math.min(a.length, b.length); i++) {
+    if (a.charAt(i) === b.charAt(i)) {
+      prefixLength++;
+    } else {
+      break;
+    }
+  }
+  const scalingFactor = 0.1;
+  return jaro + prefixLength * scalingFactor * (1 - jaro);
+}
+function calculateSimilarity(toolId, candidateId, description = "") {
+  const lowerToolId = toolId.toLowerCase();
+  const lowerCandidate = candidateId.toLowerCase();
+  const prefix = lowerToolId.split("-")[0];
+  const hasPrefix = lowerToolId.includes("-");
+  const jwScore = jaroWinklerSimilarity(lowerToolId, lowerCandidate);
+  const maxLen = Math.max(lowerToolId.length, lowerCandidate.length);
+  const lvScore = maxLen === 0 ? 1 : 1 - levenshteinDistance(lowerToolId, lowerCandidate) / maxLen;
+  let substringBoost = 0;
+  if (lowerCandidate.includes(lowerToolId) || lowerToolId.includes(lowerCandidate)) {
+    substringBoost = 0.4;
+  }
+  let prefixBoost = 0;
+  if (hasPrefix && lowerCandidate === prefix) {
+    prefixBoost = 0.5;
+  }
+  if (hasPrefix && lowerCandidate.startsWith(prefix + "-")) {
+    prefixBoost = 0.35;
+  }
+  const descMatch = description.toLowerCase().includes(lowerToolId) ? 0.1 : 0;
+  return jwScore * 0.4 + lvScore * 0.25 + substringBoost + prefixBoost + descMatch;
+}
+function findSimilarToolIds(toolId, toolIds) {
+  const scored = toolIds.map((id) => ({
+    id,
+    score: calculateSimilarity(toolId, id)
+  }));
+  return scored.filter((item) => item.score > 0.35).sort((a, b) => b.score - a.score).slice(0, 5).map((item) => item.id);
+}
 async function describeTool(args) {
   const toolId = args[0];
   if (!toolId) {
@@ -220,6 +344,17 @@ async function describeTool(args) {
     console.log();
   } catch (error) {
     console.error(`Error: Tool '${toolId}' not found`);
+    try {
+      const allNodeIds = await fetchAllNodeIds(rainfall);
+      const suggestions = findSimilarToolIds(toolId, allNodeIds);
+      if (suggestions.length > 0) {
+        console.error("\nDid you mean:");
+        for (const suggestion of suggestions) {
+          console.error(`  \u2022 ${suggestion}`);
+        }
+      }
+    } catch {
+    }
     process.exit(1);
   }
 }
@@ -263,20 +398,30 @@ Options:
   -p, --params <json>    Tool parameters as JSON string
   -f, --file <path>      Read parameters from JSON file
   --raw                  Output raw JSON (no formatting)
+  --table                Output as table (if applicable)
+  --terminal             Output for terminal consumption (minimal formatting)
+  --target-edge <id>     Execute on specific edge node (for cross-node jobs)
   --<key> <value>        Pass individual parameters (e.g., --query "AI news")
+                         Arrays: --tickers AAPL,GOOGL (comma-separated)
+                         Numbers: --count 42
+                         Booleans: --enabled true
 
 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 finviz-quotes --tickers AAPL,GOOGL,MSFT
   rainfall run github-create-issue --owner facebook --repo react --title "Bug"
   rainfall run github-create-issue -f ./issue.json
+  rainfall run exa-web-search --query "latest AI" --target-edge <edge-id>
   echo '{"query": "hello"}' | rainfall run exa-web-search
 `);
     return;
   }
   let params = {};
   const rawArgs = [];
+  let displayMode = "pretty";
+  let targetEdge;
   for (let i = 1; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--params" || arg === "-p") {
@@ -304,16 +449,23 @@ Examples:
         process.exit(1);
       }
     } else if (arg === "--raw") {
+      displayMode = "raw";
+    } else if (arg === "--table") {
+      displayMode = "table";
+    } else if (arg === "--terminal") {
+      displayMode = "terminal";
+    } else if (arg === "--target-edge") {
+      targetEdge = args[++i];
+      if (!targetEdge) {
+        console.error("Error: --target-edge requires an edge node ID");
+        process.exit(1);
+      }
     } 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] = true;
+      } else {
         params[key] = value;
       }
     } else {
@@ -355,30 +507,110 @@ 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] };
-        }
+  let toolSchema;
+  try {
+    const fullSchema = await rainfall.getToolSchema(toolId);
+    toolSchema = {
+      parameters: fullSchema.parameters
+    };
+  } catch {
+  }
+  const cliFlags = /* @__PURE__ */ new Set(["--params", "-p", "--file", "-f", "--raw", "--table", "--terminal", "--target-edge"]);
+  const toolArgs = args.slice(1).filter((arg, i, arr) => {
+    if (cliFlags.has(arg)) {
+      return false;
+    }
+    if (i > 0 && cliFlags.has(arr[i - 1])) {
+      return false;
+    }
+    return true;
+  });
+  if (toolSchema?.parameters) {
+    const { parseCliArgs } = await import("../param-parser-PAKCNDBX.mjs");
+    const parsedParams = parseCliArgs(
+      toolArgs,
+      {
+        name: toolId,
+        description: "",
+        category: "",
+        parameters: toolSchema.parameters
       }
-    } catch {
+    );
+    params = { ...parsedParams, ...params };
+  }
+  if (rawArgs.length === 1 && Object.keys(params).length === 0 && toolSchema?.parameters) {
+    const paramEntries = Object.entries(toolSchema.parameters);
+    const requiredParams = paramEntries.filter(([, p]) => !p.optional);
+    if (requiredParams.length === 1) {
+      const [paramName, paramSchema] = requiredParams[0];
+      const { parseValue } = await import("../param-parser-PAKCNDBX.mjs");
+      params = { [paramName]: parseValue(rawArgs[0], paramSchema) };
     }
   }
+  const handler = globalHandlerRegistry.findHandler(toolId);
+  const toolContext = {
+    rainfall,
+    toolId,
+    params,
+    args: rawArgs,
+    flags: { raw: displayMode === "raw" }
+  };
   try {
-    const result = await rainfall.executeTool(toolId, params);
-    if (args.includes("--raw")) {
-      console.log(JSON.stringify(result));
+    let executionParams = params;
+    let preflightContext;
+    let skipExecution;
+    if (handler?.preflight) {
+      const preflightResult = await handler.preflight(toolContext);
+      if (preflightResult) {
+        if (preflightResult.skipExecution !== void 0) {
+          skipExecution = preflightResult.skipExecution;
+        }
+        if (preflightResult.params) {
+          executionParams = preflightResult.params;
+        }
+        preflightContext = preflightResult.context;
+      }
+    }
+    let result;
+    if (skipExecution !== void 0) {
+      result = skipExecution;
+    } else if (targetEdge) {
+      result = await rainfall.executeTool(toolId, executionParams, { targetEdge });
     } else {
-      console.log(JSON.stringify(result, null, 2));
+      result = await rainfall.executeTool(toolId, executionParams);
+    }
+    const postflightContext = {
+      ...toolContext,
+      result,
+      preflightContext
+    };
+    if (handler?.postflight) {
+      await handler.postflight(postflightContext);
+    }
+    let displayed = false;
+    if (handler?.display) {
+      displayed = await handler.display({ ...postflightContext, flags: { ...toolContext.flags, mode: displayMode } });
+    }
+    if (!displayed) {
+      const output = await formatResult(result, { mode: displayMode });
+      console.log(output);
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`Error: ${message}`);
+    if (message.toLowerCase().includes("not found") || message.toLowerCase().includes("not found")) {
+      try {
+        const allNodeIds = await fetchAllNodeIds(rainfall);
+        const suggestions = findSimilarToolIds(toolId, allNodeIds);
+        if (suggestions.length > 0) {
+          console.error("\nDid you mean:");
+          for (const suggestion of suggestions) {
+            console.error(`  \u2022 ${suggestion}`);
+          }
+        }
+      } catch {
+      }
+    }
     process.exit(1);
   }
 }
@@ -671,7 +903,7 @@ async function edgeGenerateKeys() {
     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("  2. Register proc node with: rainfall edge register <proc-node-id> --public-key <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) {
@@ -679,6 +911,98 @@ async function edgeGenerateKeys() {
     process.exit(1);
   }
 }
+async function edgeRegister(args) {
+  const procNodeId = args[0];
+  if (!procNodeId) {
+    console.error("Error: Proc node ID required");
+    console.error("\nUsage: rainfall edge register <proc-node-id> [options]");
+    console.error("\nOptions:");
+    console.error("  --public-key <key>    Public key for encryption (optional)");
+    console.error("  --list <id1,id2,...>  Register multiple proc nodes (comma-separated)");
+    console.error("\nExamples:");
+    console.error("  rainfall edge register exa-web-search");
+    console.error('  rainfall edge register exa-web-search --public-key "base64key..."');
+    console.error('  rainfall edge register --list "exa-web-search,github-create-issue"');
+    process.exit(1);
+  }
+  const rainfall = getRainfall();
+  const config = loadConfig();
+  let publicKey;
+  let procNodeIds = [procNodeId];
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--public-key" || arg === "-k") {
+      publicKey = args[++i];
+    } else if (arg === "--list" || arg === "-l") {
+      const list = args[++i];
+      if (list) {
+        procNodeIds = list.split(",").map((id) => id.trim());
+      }
+    }
+  }
+  if (!publicKey) {
+    const configDir = getConfigDir();
+    const keysDir = join(configDir, "keys");
+    const publicKeyPath = join(keysDir, "edge-node.pub");
+    if (existsSync(publicKeyPath)) {
+      publicKey = readFileSync(publicKeyPath, "utf-8");
+    }
+  }
+  console.log(`\u{1F310} Registering ${procNodeIds.length} proc node(s) for edge execution...
+`);
+  try {
+    let edgeNodeId = config.edgeNodeId;
+    if (!edgeNodeId) {
+      console.log("\u{1F4E1} Registering edge node with backend...");
+      const registerResult = await rainfall.executeTool("register-edge-node", {
+        hostname: process.env.HOSTNAME || "local-edge",
+        capabilities: procNodeIds,
+        version: "1.0.0",
+        metadata: {
+          publicKey: publicKey || void 0,
+          source: "rainfall-devkit-cli"
+        }
+      });
+      edgeNodeId = registerResult.edgeNodeId;
+      console.log(`   Edge node registered: ${edgeNodeId}`);
+    } else {
+      console.log(`   Using existing edge node: ${edgeNodeId}`);
+    }
+    console.log("\n\u{1F4E1} Registering proc nodes...");
+    const result = await rainfall.executeTool("register-proc-edge-nodes", {
+      edgeNodeId,
+      procNodeIds,
+      publicKey,
+      hostname: process.env.HOSTNAME || "local-edge"
+    });
+    if (!result.success) {
+      console.error("\u274C Registration failed");
+      process.exit(1);
+    }
+    config.edgeNodeId = result.edgeNodeId;
+    config.edgeNodeSecret = result.edgeNodeSecret;
+    config.edgeNodeKeysPath = join(getConfigDir(), "keys");
+    saveConfig(config);
+    console.log("\u2705 Proc node(s) registered successfully!\n");
+    console.log("Edge Node ID:", result.edgeNodeId);
+    console.log("Proc Nodes Registered:");
+    for (const nodeId of result.registeredProcNodes) {
+      console.log(`  \u2022 ${nodeId}`);
+    }
+    console.log("\n\u{1F510} Edge node secret stored in config.");
+    console.log("   This secret is used for authentication with the backend.");
+    console.log("\n\u{1F4CB} You can now run tools on this edge node:");
+    console.log(`   rainfall run ${procNodeIds[0]} --target-edge ${result.edgeNodeId}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("\u274C Failed to register proc node:", message);
+    if (message.includes("not found") || message.includes("does not exist")) {
+      console.error("\n\u{1F4A1} The backend may not have the registration tools yet.");
+      console.error("   Make sure you are running the latest version of Rainyday.");
+    }
+    process.exit(1);
+  }
+}
 async function edgeStatus() {
   const configDir = getConfigDir();
   const keysDir = join(configDir, "keys");
@@ -696,23 +1020,36 @@ async function edgeStatus() {
     console.log("  " + publicKey.substring(0, 50) + "...");
   }
   const config = loadConfig();
+  console.log("\nRegistration:");
   if (config.edgeNodeId) {
-    console.log("\nRegistration:");
     console.log("  Edge Node ID:", config.edgeNodeId);
+  } else {
+    console.log("  Edge Node ID: \u274C Not registered");
   }
   if (config.edgeNodeSecret) {
-    console.log("  JWT Secret: \u2705 Present (expires: check with backend)");
+    console.log("  JWT Secret: \u2705 Present");
+    const masked = config.edgeNodeSecret.substring(0, 10) + "..." + config.edgeNodeSecret.substring(config.edgeNodeSecret.length - 4);
+    console.log("    (" + masked + ")");
   } else {
     console.log("  JWT Secret: \u274C Not configured");
   }
+  if (config.procNodeIds && config.procNodeIds.length > 0) {
+    console.log("\nRegistered Proc Nodes:");
+    for (const nodeId of config.procNodeIds) {
+      console.log(`  \u2022 ${nodeId}`);
+    }
+  }
   console.log("\n\u{1F4DA} Next steps:");
   if (!hasPublicKey) {
     console.log("  1. Run: rainfall edge generate-keys");
+    console.log("  2. Run: rainfall edge register <proc-node-id>");
   } else if (!config.edgeNodeSecret) {
-    console.log("  1. Register your edge node with the backend");
-    console.log("  2. Store the returned edgeNodeSecret in config");
+    console.log("  1. Register your proc node:");
+    console.log("     rainfall edge register exa-web-search");
   } else {
     console.log("  Edge node is configured and ready for secure operation");
+    console.log("  Run tools on this edge node:");
+    console.log(`     rainfall run <tool> --target-edge ${config.edgeNodeId}`);
   }
 }
 async function main() {
@@ -825,12 +1162,15 @@ async function main() {
         case "generate-keys":
           await edgeGenerateKeys();
           break;
+        case "register":
+          await edgeRegister(rest);
+          break;
         case "status":
           await edgeStatus();
           break;
         default:
           console.error("Error: Unknown edge subcommand");
-          console.error("\nUsage: rainfall edge <generate-keys|status>");
+          console.error("\nUsage: rainfall edge <generate-keys|register|status>");
           process.exit(1);
       }
       break;

package/dist/daemon/index.d.mts

@@ -1,6 +1,6 @@
-import { R as RainfallConfig, g as MCPClientConfig, h as MCPProxyHub } from '../sdk-4OvXPr8E.mjs';
-export { i as MCPClientInfo, j as MCPToolInfo, k as MCPTransportType } from '../sdk-4OvXPr8E.mjs';
-import { N as NetworkedExecutorOptions, C as ContextOptions, R as RainfallNetworkedExecutor, a as RainfallDaemonContext, b as RainfallListenerRegistry } from '../listeners-MNAnpZj-.mjs';
+import { R as RainfallConfig, g as MCPClientConfig, h as MCPProxyHub } from '../sdk-BUVNdBc7.mjs';
+export { i as MCPClientInfo, j as MCPToolInfo, k as MCPTransportType } from '../sdk-BUVNdBc7.mjs';
+import { N as NetworkedExecutorOptions, C as ContextOptions, R as RainfallNetworkedExecutor, a as RainfallDaemonContext, b as RainfallListenerRegistry } from '../listeners-BGdrWpkP.mjs';
 import 'ws';
 import '@modelcontextprotocol/sdk/client/index.js';
 import '@modelcontextprotocol/sdk/client/stdio.js';

package/dist/daemon/index.d.ts

@@ -1,6 +1,6 @@
-import { R as RainfallConfig, g as MCPClientConfig, h as MCPProxyHub } from '../sdk-4OvXPr8E.js';
-export { i as MCPClientInfo, j as MCPToolInfo, k as MCPTransportType } from '../sdk-4OvXPr8E.js';
-import { N as NetworkedExecutorOptions, C as ContextOptions, R as RainfallNetworkedExecutor, a as RainfallDaemonContext, b as RainfallListenerRegistry } from '../listeners-B5Vy9Ao5.js';
+import { R as RainfallConfig, g as MCPClientConfig, h as MCPProxyHub } from '../sdk-BUVNdBc7.js';
+export { i as MCPClientInfo, j as MCPToolInfo, k as MCPTransportType } from '../sdk-BUVNdBc7.js';
+import { N as NetworkedExecutorOptions, C as ContextOptions, R as RainfallNetworkedExecutor, a as RainfallDaemonContext, b as RainfallListenerRegistry } from '../listeners-BCEypw1u.js';
 import 'ws';
 import '@modelcontextprotocol/sdk/client/index.js';
 import '@modelcontextprotocol/sdk/client/stdio.js';