@rainfall-devkit/sdk 0.2.1 → 0.2.3

package/dist/cli/index.js

@@ -41,6 +41,19 @@ var init_cjs_shims = __esm({
 });
 
 // src/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  AuthenticationError: () => AuthenticationError,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  RainfallError: () => RainfallError,
+  RateLimitError: () => RateLimitError,
+  ServerError: () => ServerError,
+  TimeoutError: () => TimeoutError,
+  ToolNotFoundError: () => ToolNotFoundError,
+  ValidationError: () => ValidationError,
+  parseErrorResponse: () => parseErrorResponse
+});
 function parseErrorResponse(response, data) {
   const statusCode = response.status;
   if (statusCode === 429) {
@@ -89,7 +102,7 @@ function parseErrorResponse(response, data) {
       );
   }
 }
-var RainfallError, AuthenticationError, RateLimitError, ValidationError, NotFoundError, ServerError, TimeoutError, NetworkError;
+var RainfallError, AuthenticationError, RateLimitError, ValidationError, NotFoundError, ServerError, TimeoutError, NetworkError, ToolNotFoundError;
 var init_errors = __esm({
   "src/errors.ts"() {
     "use strict";
@@ -175,6 +188,179 @@ var init_errors = __esm({
         Object.setPrototypeOf(this, _NetworkError.prototype);
       }
     };
+    ToolNotFoundError = class _ToolNotFoundError extends RainfallError {
+      constructor(toolId) {
+        super(`Tool '${toolId}' not found`, "TOOL_NOT_FOUND", 404, { toolId });
+        this.name = "ToolNotFoundError";
+        Object.setPrototypeOf(this, _ToolNotFoundError.prototype);
+      }
+    };
+  }
+});
+
+// src/validation.ts
+async function fetchToolSchema(client, toolId) {
+  const cached = schemaCache.get(toolId);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+    return cached.schema;
+  }
+  const response = await client.request(
+    `/olympic/subscribers/me/nodes/${toolId}/params`
+  );
+  if (!response.success || !response.params) {
+    throw new ValidationError(`Failed to fetch schema for tool '${toolId}'`);
+  }
+  schemaCache.set(toolId, { schema: response.params, timestamp: Date.now() });
+  return response.params;
+}
+function validateParams(schema, params, toolId) {
+  const errors = [];
+  const parameters = schema.parameters || {};
+  for (const [key, paramSchema] of Object.entries(parameters)) {
+    if (paramSchema.optional !== true && !(key in (params || {}))) {
+      errors.push({
+        path: key,
+        message: `Missing required parameter '${key}'`,
+        expected: paramSchema.type
+      });
+    }
+  }
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      const paramSchema = parameters[key];
+      if (!paramSchema) {
+        errors.push({
+          path: key,
+          message: `Unknown parameter '${key}'`,
+          received: value
+        });
+        continue;
+      }
+      const typeError = validateType(key, value, paramSchema);
+      if (typeError) {
+        errors.push(typeError);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateType(path, value, schema) {
+  if (value === null || value === void 0) {
+    if (schema.optional === true) {
+      return null;
+    }
+    return {
+      path,
+      message: `Parameter '${path}' is required but received ${value}`,
+      received: value,
+      expected: schema.type
+    };
+  }
+  const expectedType = schema.type;
+  const actualType = getJsType(value);
+  switch (expectedType) {
+    case "string":
+      if (typeof value !== "string") {
+        return {
+          path,
+          message: `Parameter '${path}' must be a string, received ${actualType}`,
+          received: value,
+          expected: "string"
+        };
+      }
+      break;
+    case "number":
+      if (typeof value !== "number" || isNaN(value)) {
+        return {
+          path,
+          message: `Parameter '${path}' must be a number, received ${actualType}`,
+          received: value,
+          expected: "number"
+        };
+      }
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return {
+          path,
+          message: `Parameter '${path}' must be a boolean, received ${actualType}`,
+          received: value,
+          expected: "boolean"
+        };
+      }
+      break;
+    case "array":
+      if (!Array.isArray(value)) {
+        return {
+          path,
+          message: `Parameter '${path}' must be an array, received ${actualType}`,
+          received: value,
+          expected: "array"
+        };
+      }
+      if (schema.items) {
+        for (let i = 0; i < value.length; i++) {
+          const itemError = validateType(`${path}[${i}]`, value[i], schema.items);
+          if (itemError) {
+            return itemError;
+          }
+        }
+      }
+      break;
+    case "object":
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return {
+          path,
+          message: `Parameter '${path}' must be an object, received ${actualType}`,
+          received: value,
+          expected: "object"
+        };
+      }
+      if (schema.properties) {
+        const objValue = value;
+        for (const [propKey, propSchema] of Object.entries(schema.properties)) {
+          if (objValue[propKey] !== void 0) {
+            const propError = validateType(`${path}.${propKey}`, objValue[propKey], propSchema);
+            if (propError) {
+              return propError;
+            }
+          }
+        }
+      }
+      break;
+    default:
+      break;
+  }
+  return null;
+}
+function getJsType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function formatValidationErrors(result) {
+  if (result.valid) return "No validation errors";
+  const lines = result.errors.map((err) => {
+    let line = `  - ${err.message}`;
+    if (err.received !== void 0) {
+      line += ` (received: ${JSON.stringify(err.received).slice(0, 50)})`;
+    }
+    return line;
+  });
+  return `Validation failed with ${result.errors.length} error(s):
+${lines.join("\n")}`;
+}
+var schemaCache, CACHE_TTL_MS;
+var init_validation = __esm({
+  "src/validation.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_errors();
+    schemaCache = /* @__PURE__ */ new Map();
+    CACHE_TTL_MS = 5 * 60 * 1e3;
   }
 });
 
@@ -185,6 +371,7 @@ var init_client = __esm({
     "use strict";
     init_cjs_shims();
     init_errors();
+    init_validation();
     DEFAULT_BASE_URL = "https://olympic-api.pragma-digital.org/v1";
     DEFAULT_TIMEOUT = 3e4;
     DEFAULT_RETRIES = 3;
@@ -195,6 +382,7 @@ var init_client = __esm({
       defaultTimeout;
       defaultRetries;
       defaultRetryDelay;
+      disableValidation;
       lastRateLimitInfo;
       subscriberId;
       constructor(config) {
@@ -203,6 +391,7 @@ var init_client = __esm({
         this.defaultTimeout = config.timeout || DEFAULT_TIMEOUT;
         this.defaultRetries = config.retries ?? DEFAULT_RETRIES;
         this.defaultRetryDelay = config.retryDelay || DEFAULT_RETRY_DELAY;
+        this.disableValidation = config.disableValidation ?? false;
       }
       /**
        * Get the last rate limit info from the API
@@ -285,15 +474,68 @@ var init_client = __esm({
       }
       /**
        * Execute a tool/node by ID
+       * 
+       * @param toolId - The ID of the tool/node to execute
+       * @param params - Parameters to pass to the tool
+       * @param options - Request options including skipValidation to bypass param validation
        */
       async executeTool(toolId, params, options) {
+        if (!this.disableValidation && !options?.skipValidation) {
+          const validation = await this.validateToolParams(toolId, params);
+          if (!validation.valid) {
+            const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+            throw new ValidationError2(
+              `Parameter validation failed for tool '${toolId}': ${formatValidationErrors(validation)}`,
+              { toolId, errors: validation.errors }
+            );
+          }
+        }
         const subscriberId = await this.ensureSubscriberId();
         const response = await this.request(`/olympic/subscribers/${subscriberId}/nodes/${toolId}`, {
           method: "POST",
           body: params || {}
         }, options);
+        if (response.success === false) {
+          const errorMessage = typeof response.error === "string" ? response.error : JSON.stringify(response.error);
+          throw new RainfallError(
+            `Tool execution failed: ${errorMessage}`,
+            "TOOL_EXECUTION_ERROR",
+            400,
+            { toolId, error: response.error }
+          );
+        }
         return response.result;
       }
+      /**
+       * Validate parameters for a tool without executing it
+       * Fetches the tool schema and validates the provided params
+       * 
+       * @param toolId - The ID of the tool to validate params for
+       * @param params - Parameters to validate
+       * @returns Validation result with detailed error information
+       * 
+       * @example
+       * ```typescript
+       * const result = await client.validateToolParams('finviz-quotes', { tickers: ['AAPL'] });
+       * if (!result.valid) {
+       *   console.log('Validation errors:', result.errors);
+       * }
+       * ```
+       */
+      async validateToolParams(toolId, params) {
+        try {
+          const schema = await fetchToolSchema(this, toolId);
+          return validateParams(schema, params, toolId);
+        } catch (error) {
+          if (error instanceof RainfallError && error.statusCode === 404) {
+            return {
+              valid: false,
+              errors: [{ path: toolId, message: `Tool '${toolId}' not found` }]
+            };
+          }
+          return { valid: true, errors: [] };
+        }
+      }
       /**
        * List all available tools
        */
@@ -316,11 +558,20 @@ var init_client = __esm({
       }
       /**
        * Get tool schema/parameters
+       * 
+       * @param toolId - The ID of the tool to get schema for
+       * @returns Tool schema including parameters and output definitions
        */
       async getToolSchema(toolId) {
-        const subscriberId = await this.ensureSubscriberId();
-        const response = await this.request(`/olympic/subscribers/${subscriberId}/nodes/${toolId}/params`);
-        return response.params;
+        const schema = await fetchToolSchema(this, toolId);
+        return {
+          name: schema.name,
+          description: schema.description,
+          category: schema.category,
+          parameters: schema.parameters,
+          output: schema.output,
+          metadata: schema.metadata || {}
+        };
       }
       /**
        * Get subscriber info
@@ -898,9 +1149,40 @@ var init_sdk = __esm({
       }
       /**
        * Execute any tool by ID (low-level access)
+       * 
+       * @param toolId - The ID of the tool to execute
+       * @param params - Parameters to pass to the tool
+       * @param options - Execution options including skipValidation to bypass param validation
+       * 
+       * @example
+       * ```typescript
+       * // Execute with validation (default)
+       * const result = await rainfall.executeTool('finviz-quotes', { tickers: ['AAPL'] });
+       * 
+       * // Execute without validation
+       * const result = await rainfall.executeTool('finviz-quotes', { tickers: ['AAPL'] }, { skipValidation: true });
+       * ```
        */
-      async executeTool(toolId, params) {
-        return this.client.executeTool(toolId, params);
+      async executeTool(toolId, params, options) {
+        return this.client.executeTool(toolId, params, options);
+      }
+      /**
+       * Validate parameters for a tool without executing it
+       * 
+       * @param toolId - The ID of the tool to validate params for
+       * @param params - Parameters to validate
+       * @returns Validation result with detailed error information
+       * 
+       * @example
+       * ```typescript
+       * const result = await rainfall.validateToolParams('finviz-quotes', { tickers: ['AAPL'] });
+       * if (!result.valid) {
+       *   console.log('Validation errors:', result.errors);
+       * }
+       * ```
+       */
+      async validateToolParams(toolId, params) {
+        return this.client.validateToolParams(toolId, params);
       }
       /**
        * Get current subscriber info and usage
@@ -1058,6 +1340,291 @@ var init_config = __esm({
   }
 });
 
+// src/cli/core/display.ts
+var display_exports = {};
+__export(display_exports, {
+  detectImageData: () => detectImageData,
+  detectImageSupport: () => detectImageSupport,
+  displayImage: () => displayImage,
+  formatAsTable: () => formatAsTable,
+  formatResult: () => formatResult
+});
+function detectImageSupport() {
+  if (process.env.TERM_PROGRAM === "iTerm.app") {
+    return { supported: true, command: "imgcat" };
+  }
+  if (process.env.KITTY_WINDOW_ID) {
+    return { supported: true, command: "kitty +kitten icat" };
+  }
+  try {
+    return { supported: true, command: "xan" };
+  } catch {
+  }
+  try {
+    return { supported: true, command: "catimg" };
+  } catch {
+  }
+  return { supported: false };
+}
+async function displayImage(imageData, options = {}) {
+  const imageCommand = options.imageCommand || detectImageSupport().command;
+  if (!imageCommand) {
+    const { writeFileSync: writeFileSync3 } = await import("fs");
+    const { tmpdir } = await import("os");
+    const { join: join3 } = await import("path");
+    const tempPath = join3(tmpdir(), `rainfall-image-${Date.now()}.png`);
+    const buffer = typeof imageData === "string" ? Buffer.from(imageData, "base64") : imageData;
+    writeFileSync3(tempPath, buffer);
+    console.log(`Image saved to: ${tempPath}`);
+    return;
+  }
+  return new Promise((resolve, reject) => {
+    const buffer = typeof imageData === "string" ? Buffer.from(imageData, "base64") : imageData;
+    const child = (0, import_child_process.spawn)(imageCommand, [], {
+      stdio: ["pipe", "inherit", "inherit"],
+      shell: true
+    });
+    child.stdin.write(buffer);
+    child.stdin.end();
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Image display failed with code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+function formatAsTable(data, columns) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return "No data";
+  }
+  const cols = columns || Object.keys(data[0]);
+  const widths = {};
+  for (const col of cols) {
+    widths[col] = Math.max(
+      col.length,
+      ...data.map((row) => {
+        const val = row?.[col];
+        return String(val ?? "").slice(0, 50).length;
+      })
+    );
+  }
+  const lines = [];
+  const header = cols.map((col) => col.padEnd(widths[col])).join("  ");
+  lines.push(header);
+  lines.push(cols.map((col) => "-".repeat(widths[col])).join("  "));
+  for (const row of data) {
+    const line = cols.map((col) => {
+      const val = row?.[col];
+      const str = String(val ?? "").slice(0, 50);
+      return str.padEnd(widths[col]);
+    }).join("  ");
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+async function formatResult(result, options = {}) {
+  const mode = options.mode || "pretty";
+  switch (mode) {
+    case "raw":
+      return JSON.stringify(result);
+    case "pretty":
+      return JSON.stringify(result, null, 2);
+    case "table":
+      if (Array.isArray(result)) {
+        return formatAsTable(result, options.columns);
+      }
+      return JSON.stringify(result, null, 2);
+    case "terminal":
+      if (typeof result === "string") {
+        return result;
+      }
+      if (Array.isArray(result) && result.every((r) => typeof r === "string")) {
+        return result.join("\n");
+      }
+      return JSON.stringify(result);
+    default:
+      return JSON.stringify(result, null, 2);
+  }
+}
+function detectImageData(result) {
+  if (!result || typeof result !== "object") {
+    return { hasImage: false };
+  }
+  const obj = result;
+  const imageFields = ["image", "imageData", "imageBase64", "png", "jpeg", "data"];
+  for (const field of imageFields) {
+    if (obj[field] && typeof obj[field] === "string") {
+      const value = obj[field];
+      if (value.startsWith("data:image/") || value.length > 100) {
+        return {
+          hasImage: true,
+          imageData: value.startsWith("data:image/") ? value.split(",")[1] : value
+        };
+      }
+    }
+  }
+  if (obj.url && typeof obj.url === "string" && (obj.url.endsWith(".png") || obj.url.endsWith(".jpg") || obj.url.endsWith(".jpeg"))) {
+    return { hasImage: true, imagePath: obj.url };
+  }
+  return { hasImage: false };
+}
+var import_child_process;
+var init_display = __esm({
+  "src/cli/core/display.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_child_process = require("child_process");
+  }
+});
+
+// src/cli/core/param-parser.ts
+var param_parser_exports = {};
+__export(param_parser_exports, {
+  formatValueForDisplay: () => formatValueForDisplay,
+  generateParamExample: () => generateParamExample,
+  parseCliArgs: () => parseCliArgs,
+  parseValue: () => parseValue
+});
+function parseValue(value, schema, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (!schema) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  const expectedType = schema.type;
+  switch (expectedType) {
+    case "array":
+      return parseArrayValue(value, schema, opts);
+    case "number":
+      return parseNumberValue(value, opts);
+    case "boolean":
+      return parseBooleanValue(value, opts);
+    case "string":
+      return value;
+    case "object":
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    default:
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+  }
+}
+function parseArrayValue(value, schema, options) {
+  if (value.startsWith("[") && value.endsWith("]")) {
+    try {
+      return JSON.parse(value);
+    } catch {
+    }
+  }
+  if (options.arrayInterpolation && value.includes(options.arraySeparator)) {
+    const items = value.split(options.arraySeparator).map((s) => s.trim()).filter(Boolean);
+    if (schema.items) {
+      return items.map((item) => parseValue(item, schema.items, { ...options, arrayInterpolation: false }));
+    }
+    return items;
+  }
+  if (schema.items) {
+    return [parseValue(value, schema.items, { ...options, arrayInterpolation: false })];
+  }
+  return [value];
+}
+function parseNumberValue(value, options) {
+  if (!options.numberParsing) {
+    return value;
+  }
+  const num = Number(value);
+  if (!isNaN(num) && isFinite(num)) {
+    return num;
+  }
+  return value;
+}
+function parseBooleanValue(value, options) {
+  if (!options.booleanParsing) {
+    return value;
+  }
+  const lower = value.toLowerCase();
+  if (lower === "true" || lower === "yes" || lower === "1" || lower === "on") {
+    return true;
+  }
+  if (lower === "false" || lower === "no" || lower === "0" || lower === "off") {
+    return false;
+  }
+  return value;
+}
+function parseCliArgs(args, schema, options = {}) {
+  const params = {};
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const parameters = schema?.parameters || {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const value = args[++i];
+      if (value === void 0) {
+        params[key] = true;
+        continue;
+      }
+      const paramSchema = parameters[key];
+      params[key] = parseValue(value, paramSchema, opts);
+    }
+  }
+  return params;
+}
+function formatValueForDisplay(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    return value.map(formatValueForDisplay).join(",");
+  }
+  return JSON.stringify(value);
+}
+function generateParamExample(key, schema) {
+  const type = schema.type || "string";
+  switch (type) {
+    case "array":
+      if (schema.items?.type === "string") {
+        return `--${key} item1,item2,item3`;
+      }
+      return `--${key} '["item1", "item2"]'`;
+    case "number":
+      return `--${key} 42`;
+    case "boolean":
+      return `--${key} true`;
+    case "object":
+      return `--${key} '{"key": "value"}'`;
+    default:
+      return `--${key} "value"`;
+  }
+}
+var DEFAULT_OPTIONS;
+var init_param_parser = __esm({
+  "src/cli/core/param-parser.ts"() {
+    "use strict";
+    init_cjs_shims();
+    DEFAULT_OPTIONS = {
+      arrayInterpolation: true,
+      numberParsing: true,
+      booleanParsing: true,
+      arraySeparator: ","
+    };
+  }
+});
+
 // src/services/networked.ts
 var RainfallNetworkedExecutor;
 var init_networked = __esm({
@@ -1717,7 +2284,7 @@ var init_listeners = __esm({
 });
 
 // src/services/mcp-proxy.ts
-var import_ws, import_client2, import_stdio, import_streamableHttp, import_types, MCPProxyHub;
+var import_ws, import_client2, import_stdio, import_streamableHttp, import_types2, MCPProxyHub;
 var init_mcp_proxy = __esm({
   "src/services/mcp-proxy.ts"() {
     "use strict";
@@ -1726,7 +2293,7 @@ var init_mcp_proxy = __esm({
     import_client2 = require("@modelcontextprotocol/sdk/client/index.js");
     import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
     import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
-    import_types = require("@modelcontextprotocol/sdk/types.js");
+    import_types2 = require("@modelcontextprotocol/sdk/types.js");
     MCPProxyHub = class {
       clients = /* @__PURE__ */ new Map();
       options;
@@ -1845,7 +2412,7 @@ var init_mcp_proxy = __esm({
               method: "tools/list",
               params: {}
             },
-            import_types.ListToolsResultSchema
+            import_types2.ListToolsResultSchema
           );
           const tools = toolsResult.tools.map((tool) => ({
             name: tool.name,
@@ -1959,7 +2526,7 @@ var init_mcp_proxy = __esm({
                   arguments: args
                 }
               },
-              import_types.CallToolResultSchema
+              import_types2.CallToolResultSchema
             ),
             new Promise(
               (_, reject) => setTimeout(() => reject(new Error(`Tool call timeout after ${timeout}ms`)), timeout)
@@ -1969,7 +2536,7 @@ var init_mcp_proxy = __esm({
           return this.formatToolResult(result);
         } catch (error) {
           this.log(`[${requestId}] Failed:`, error instanceof Error ? error.message : error);
-          if (error instanceof import_types.McpError) {
+          if (error instanceof import_types2.McpError) {
             throw new Error(`MCP Error (${toolName}): ${error.message} (code: ${error.code})`);
           }
           throw error;
@@ -2053,7 +2620,7 @@ var init_mcp_proxy = __esm({
                 method: "tools/list",
                 params: {}
               },
-              import_types.ListToolsResultSchema
+              import_types2.ListToolsResultSchema
             );
             client.tools = toolsResult.tools.map((tool) => ({
               name: tool.name,
@@ -2084,7 +2651,7 @@ var init_mcp_proxy = __esm({
                 method: "resources/list",
                 params: {}
               },
-              import_types.ListResourcesResultSchema
+              import_types2.ListResourcesResultSchema
             );
             results.push({
               clientName: name,
@@ -2110,7 +2677,7 @@ var init_mcp_proxy = __esm({
               method: "resources/read",
               params: { uri }
             },
-            import_types.ReadResourceResultSchema
+            import_types2.ReadResourceResultSchema
           );
           return result;
         } else {
@@ -2121,7 +2688,7 @@ var init_mcp_proxy = __esm({
                   method: "resources/read",
                   params: { uri }
                 },
-                import_types.ReadResourceResultSchema
+                import_types2.ReadResourceResultSchema
               );
               return { clientName: name, ...result };
             } catch {
@@ -2145,7 +2712,7 @@ var init_mcp_proxy = __esm({
                 method: "prompts/list",
                 params: {}
               },
-              import_types.ListPromptsResultSchema
+              import_types2.ListPromptsResultSchema
             );
             results.push({
               clientName: name,
@@ -2171,7 +2738,7 @@ var init_mcp_proxy = __esm({
               method: "prompts/get",
               params: { name, arguments: args }
             },
-            import_types.GetPromptResultSchema
+            import_types2.GetPromptResultSchema
           );
           return result;
         } else {
@@ -2182,7 +2749,7 @@ var init_mcp_proxy = __esm({
                   method: "prompts/get",
                   params: { name, arguments: args }
                 },
-                import_types.GetPromptResultSchema
+                import_types2.GetPromptResultSchema
               );
               return { clientName: cName, ...result };
             } catch {
@@ -2204,7 +2771,7 @@ var init_mcp_proxy = __esm({
                 method: "tools/list",
                 params: {}
               },
-              import_types.ListToolsResultSchema
+              import_types2.ListToolsResultSchema
             );
             results.set(name, {
               status: "healthy",
@@ -3274,17 +3841,17 @@ var import_path2 = require("path");
 var import_url = require("url");
 init_sdk();
 init_config();
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 
 // src/security/edge-node.ts
 init_cjs_shims();
-var sodium = __toESM(require("libsodium-wrappers"));
+var import_libsodium_wrappers_sumo = __toESM(require("libsodium-wrappers-sumo"));
 var EdgeNodeSecurity = class {
   sodiumReady;
   backendSecret;
   keyPair;
   constructor(options = {}) {
-    this.sodiumReady = sodium.ready;
+    this.sodiumReady = import_libsodium_wrappers_sumo.default.ready;
     this.backendSecret = options.backendSecret;
     this.keyPair = options.keyPair;
   }
@@ -3414,7 +3981,7 @@ var EdgeNodeSecurity = class {
    */
   async generateKeyPair() {
     await this.sodiumReady;
-    const keyPair = sodium.crypto_box_keypair();
+    const keyPair = import_libsodium_wrappers_sumo.default.crypto_box_keypair();
     return {
       publicKey: this.bytesToBase64(keyPair.publicKey),
       privateKey: this.bytesToBase64(keyPair.privateKey)
@@ -3429,10 +3996,10 @@ var EdgeNodeSecurity = class {
       throw new Error("Local key pair not configured");
     }
     const targetPublicKey = this.base64ToBytes(targetPublicKeyBase64);
-    const ephemeralKeyPair = sodium.crypto_box_keypair();
-    const nonce = sodium.randombytes_buf(sodium.crypto_box_NONCEBYTES);
+    const ephemeralKeyPair = import_libsodium_wrappers_sumo.default.crypto_box_keypair();
+    const nonce = import_libsodium_wrappers_sumo.default.randombytes_buf(import_libsodium_wrappers_sumo.default.crypto_box_NONCEBYTES);
     const message = new TextEncoder().encode(plaintext);
-    const ciphertext = sodium.crypto_box_easy(
+    const ciphertext = import_libsodium_wrappers_sumo.default.crypto_box_easy(
       message,
       nonce,
       targetPublicKey,
@@ -3456,7 +4023,7 @@ var EdgeNodeSecurity = class {
     const ephemeralPublicKey = this.base64ToBytes(encrypted.ephemeralPublicKey);
     const nonce = this.base64ToBytes(encrypted.nonce);
     const ciphertext = this.base64ToBytes(encrypted.ciphertext);
-    const decrypted = sodium.crypto_box_open_easy(
+    const decrypted = import_libsodium_wrappers_sumo.default.crypto_box_open_easy(
       ciphertext,
       nonce,
       ephemeralPublicKey,
@@ -3473,9 +4040,9 @@ var EdgeNodeSecurity = class {
   async encryptLocal(plaintext, key) {
     await this.sodiumReady;
     const keyBytes = this.deriveKey(key);
-    const nonce = sodium.randombytes_buf(sodium.crypto_secretbox_NONCEBYTES);
+    const nonce = import_libsodium_wrappers_sumo.default.randombytes_buf(import_libsodium_wrappers_sumo.default.crypto_secretbox_NONCEBYTES);
     const message = new TextEncoder().encode(plaintext);
-    const ciphertext = sodium.crypto_secretbox_easy(message, nonce, keyBytes);
+    const ciphertext = import_libsodium_wrappers_sumo.default.crypto_secretbox_easy(message, nonce, keyBytes);
     return {
       ciphertext: this.bytesToBase64(ciphertext),
       nonce: this.bytesToBase64(nonce)
@@ -3489,7 +4056,7 @@ var EdgeNodeSecurity = class {
     const keyBytes = this.deriveKey(key);
     const nonce = this.base64ToBytes(encrypted.nonce);
     const ciphertext = this.base64ToBytes(encrypted.ciphertext);
-    const decrypted = sodium.crypto_secretbox_open_easy(ciphertext, nonce, keyBytes);
+    const decrypted = import_libsodium_wrappers_sumo.default.crypto_secretbox_open_easy(ciphertext, nonce, keyBytes);
     if (!decrypted) {
       throw new Error("Local decryption failed");
     }
@@ -3512,7 +4079,7 @@ var EdgeNodeSecurity = class {
   hmacSha256(message, secret) {
     const key = new TextEncoder().encode(secret);
     const msg = new TextEncoder().encode(message);
-    const hash = sodium.crypto_auth(msg, key);
+    const hash = import_libsodium_wrappers_sumo.default.crypto_auth(msg, key);
     return this.bytesToBase64(hash);
   }
   timingSafeEqual(a, b) {
@@ -3533,7 +4100,7 @@ var EdgeNodeSecurity = class {
   }
   deriveKey(password) {
     const passwordBytes = new TextEncoder().encode(password);
-    return sodium.crypto_generichash(32, passwordBytes, null);
+    return import_libsodium_wrappers_sumo.default.crypto_generichash(32, passwordBytes, null);
   }
 };
 async function createEdgeNodeSecurity(options = {}) {
@@ -3542,6 +4109,179 @@ async function createEdgeNodeSecurity(options = {}) {
   return security;
 }
 
+// src/cli/index.ts
+init_display();
+
+// src/cli/handlers/_registry.ts
+init_cjs_shims();
+
+// src/cli/core/types.ts
+init_cjs_shims();
+var ToolHandlerRegistry = class {
+  handlers = [];
+  register(handler) {
+    this.handlers.push(handler);
+  }
+  findHandler(toolId) {
+    return this.handlers.find((h) => {
+      if (typeof h.toolId === "string") {
+        return h.toolId === toolId;
+      }
+      return h.toolId.test(toolId);
+    });
+  }
+  getAllHandlers() {
+    return [...this.handlers];
+  }
+};
+var globalHandlerRegistry = new ToolHandlerRegistry();
+
+// src/cli/handlers/_registry.ts
+var imageGenerationHandler = {
+  toolId: /image-generation|generate-image/,
+  async display(context) {
+    const { detectImageData: detectImageData2, displayImage: displayImage2 } = await Promise.resolve().then(() => (init_display(), display_exports));
+    const { result, flags } = context;
+    const imageInfo = detectImageData2(result);
+    if (imageInfo.hasImage && !flags.raw) {
+      try {
+        if (imageInfo.imageData) {
+          await displayImage2(imageInfo.imageData);
+          return true;
+        }
+      } catch (error) {
+        console.warn("Failed to display image:", error instanceof Error ? error.message : error);
+      }
+    }
+    return false;
+  }
+};
+var finvizQuotesHandler = {
+  toolId: "finviz-quotes",
+  async preflight(context) {
+    const { parseValue: parseValue2 } = await Promise.resolve().then(() => (init_param_parser(), param_parser_exports));
+    const params = { ...context.params };
+    if (params.tickers && typeof params.tickers === "string") {
+      params.tickers = parseValue2(params.tickers, { type: "array", items: { type: "string" } });
+    }
+    return { params };
+  },
+  async display(context) {
+    const { result, flags } = context;
+    if (flags.raw) {
+      return false;
+    }
+    const obj = result;
+    const quotes = obj?.quotes;
+    if (Array.isArray(quotes) && quotes.length > 0) {
+      const { formatAsTable: formatAsTable2 } = await Promise.resolve().then(() => (init_display(), display_exports));
+      const tableData = quotes.map((q) => {
+        const quote = q;
+        const data = quote.data || {};
+        return {
+          Ticker: quote.ticker || data.Ticker || "-",
+          Price: data.Price || data.Close || "-",
+          Change: data.Change || "-",
+          Volume: data.Volume || "-",
+          "Market Cap": data.MarketCap || "-"
+        };
+      });
+      console.log(formatAsTable2(tableData));
+      const summary = obj?.summary;
+      if (summary && typeof summary === "string") {
+        console.log(`
+${summary}`);
+      }
+      return true;
+    }
+    return false;
+  }
+};
+var csvQueryHandler = {
+  toolId: /query-csv|csv-query/,
+  async display(context) {
+    const { result, flags } = context;
+    if (flags.raw) {
+      return false;
+    }
+    if (Array.isArray(result) && result.length > 0) {
+      const { formatAsTable: formatAsTable2 } = await Promise.resolve().then(() => (init_display(), display_exports));
+      console.log(formatAsTable2(result));
+      return true;
+    }
+    return false;
+  }
+};
+var webSearchHandler = {
+  toolId: /web-search|exa-web-search|perplexity/,
+  async display(context) {
+    const { result, flags } = context;
+    if (flags.raw) {
+      return false;
+    }
+    const obj = result;
+    if (obj.results && typeof obj.results === "string") {
+      console.log(obj.results);
+      return true;
+    }
+    if (obj.answer || obj.summary) {
+      console.log(obj.answer || obj.summary);
+      if (obj.sources && Array.isArray(obj.sources)) {
+        console.log("\n--- Sources ---");
+        obj.sources.forEach((source, i) => {
+          if (typeof source === "string") {
+            console.log(`  ${i + 1}. ${source}`);
+          } else if (source && typeof source === "object") {
+            const s = source;
+            console.log(`  ${i + 1}. ${s.title || s.url || JSON.stringify(source)}`);
+          }
+        });
+      }
+      return true;
+    }
+    return false;
+  }
+};
+var memoryRecallHandler = {
+  toolId: /memory-recall|recall/,
+  async display(context) {
+    const { result, flags } = context;
+    if (flags.raw) {
+      return false;
+    }
+    if (Array.isArray(result)) {
+      if (result.length === 0) {
+        console.log("No memories found.");
+        return true;
+      }
+      console.log(`Found ${result.length} memory(s):
+`);
+      result.forEach((mem, i) => {
+        const memory = mem;
+        console.log(`\u2500`.repeat(60));
+        console.log(`  ${i + 1}. ${memory.content || memory.text || JSON.stringify(memory).slice(0, 100)}`);
+        if (memory.similarity) {
+          console.log(`     Similarity: ${(Number(memory.similarity) * 100).toFixed(1)}%`);
+        }
+        if (memory.keywords && Array.isArray(memory.keywords)) {
+          console.log(`     Keywords: ${memory.keywords.join(", ")}`);
+        }
+        console.log();
+      });
+      return true;
+    }
+    return false;
+  }
+};
+function registerBuiltInHandlers(registry = globalHandlerRegistry) {
+  registry.register(imageGenerationHandler);
+  registry.register(finvizQuotesHandler);
+  registry.register(csvQueryHandler);
+  registry.register(webSearchHandler);
+  registry.register(memoryRecallHandler);
+}
+registerBuiltInHandlers();
+
 // src/cli/index.ts
 function printHelp() {
   console.log(`
@@ -3593,7 +4333,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)
@@ -3609,6 +4354,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
@@ -3626,6 +4372,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) {
@@ -3712,6 +4476,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) {
@@ -3747,6 +4605,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);
   }
 }
@@ -3790,12 +4659,18 @@ 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)
   --<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
   echo '{"query": "hello"}' | rainfall run exa-web-search
@@ -3804,6 +4679,7 @@ Examples:
   }
   let params = {};
   const rawArgs = [];
+  let displayMode = "pretty";
   for (let i = 1; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--params" || arg === "-p") {
@@ -3831,16 +4707,17 @@ 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.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 {
@@ -3882,30 +4759,108 @@ 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"]);
+  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: parseCliArgs2 } = await Promise.resolve().then(() => (init_param_parser(), param_parser_exports));
+    const parsedParams = parseCliArgs2(
+      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: parseValue2 } = await Promise.resolve().then(() => (init_param_parser(), param_parser_exports));
+      params = { [paramName]: parseValue2(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 {
-      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);
   }
 }
@@ -4022,7 +4977,7 @@ async function upgrade() {
   console.log(`Running: ${command} ${args.join(" ")}`);
   console.log();
   return new Promise((resolve, reject) => {
-    const child = (0, import_child_process.spawn)(command, args, {
+    const child = (0, import_child_process2.spawn)(command, args, {
       stdio: "inherit",
       shell: true
     });