@rainfall-devkit/sdk 0.2.2 → 0.2.3

package/dist/chunk-LJQEO3CY.mjs

@@ -0,0 +1,150 @@
+// src/errors.ts
+var RainfallError = class _RainfallError extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "RainfallError";
+    Object.setPrototypeOf(this, _RainfallError.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      statusCode: this.statusCode,
+      details: this.details
+    };
+  }
+};
+var AuthenticationError = class _AuthenticationError extends RainfallError {
+  constructor(message = "Invalid API key", details) {
+    super(message, "AUTHENTICATION_ERROR", 401, details);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends RainfallError {
+  retryAfter;
+  limit;
+  remaining;
+  resetAt;
+  constructor(message = "Rate limit exceeded", retryAfter = 60, limit = 0, remaining = 0, resetAt) {
+    super(message, "RATE_LIMIT_ERROR", 429, { retryAfter, limit, remaining });
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+    this.limit = limit;
+    this.remaining = remaining;
+    this.resetAt = resetAt || new Date(Date.now() + retryAfter * 1e3);
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends RainfallError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", 400, details);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var NotFoundError = class _NotFoundError extends RainfallError {
+  constructor(resource, identifier) {
+    super(
+      `${resource}${identifier ? ` '${identifier}'` : ""} not found`,
+      "NOT_FOUND_ERROR",
+      404,
+      { resource, identifier }
+    );
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+var ServerError = class _ServerError extends RainfallError {
+  constructor(message = "Internal server error", statusCode = 500) {
+    super(message, "SERVER_ERROR", statusCode);
+    this.name = "ServerError";
+    Object.setPrototypeOf(this, _ServerError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends RainfallError {
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`, "TIMEOUT_ERROR", 408);
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends RainfallError {
+  constructor(message = "Network error", details) {
+    super(message, "NETWORK_ERROR", void 0, details);
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+var 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);
+  }
+};
+function parseErrorResponse(response, data) {
+  const statusCode = response.status;
+  if (statusCode === 429) {
+    const retryAfter = parseInt(response.headers.get("retry-after") || "60", 10);
+    const limit = parseInt(response.headers.get("x-ratelimit-limit") || "0", 10);
+    const remaining = parseInt(response.headers.get("x-ratelimit-remaining") || "0", 10);
+    const resetHeader = response.headers.get("x-ratelimit-reset");
+    const resetAt = resetHeader ? new Date(parseInt(resetHeader, 10) * 1e3) : void 0;
+    return new RateLimitError(
+      typeof data === "object" && data && "message" in data ? String(data.message) : "Rate limit exceeded",
+      retryAfter,
+      limit,
+      remaining,
+      resetAt
+    );
+  }
+  switch (statusCode) {
+    case 401:
+      return new AuthenticationError(
+        typeof data === "object" && data && "message" in data ? String(data.message) : "Invalid API key"
+      );
+    case 404:
+      return new NotFoundError(
+        typeof data === "object" && data && "resource" in data ? String(data.resource) : "Resource",
+        typeof data === "object" && data && "identifier" in data ? String(data.identifier) : void 0
+      );
+    case 400:
+      return new ValidationError(
+        typeof data === "object" && data && "message" in data ? String(data.message) : "Invalid request",
+        typeof data === "object" && data && "details" in data ? data.details : void 0
+      );
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return new ServerError(
+        typeof data === "object" && data && "message" in data ? String(data.message) : "Server error",
+        statusCode
+      );
+    default:
+      return new RainfallError(
+        typeof data === "object" && data && "message" in data ? String(data.message) : `HTTP ${statusCode}`,
+        "UNKNOWN_ERROR",
+        statusCode,
+        typeof data === "object" ? data : void 0
+      );
+  }
+}
+
+export {
+  RainfallError,
+  AuthenticationError,
+  RateLimitError,
+  ValidationError,
+  NotFoundError,
+  ServerError,
+  TimeoutError,
+  NetworkError,
+  ToolNotFoundError,
+  parseErrorResponse
+};

package/dist/chunk-S7MOQCV4.mjs

@@ -0,0 +1,137 @@
+// src/cli/core/param-parser.ts
+var DEFAULT_OPTIONS = {
+  arrayInterpolation: true,
+  numberParsing: true,
+  booleanParsing: true,
+  arraySeparator: ","
+};
+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"`;
+  }
+}
+
+export {
+  parseValue,
+  parseCliArgs,
+  formatValueForDisplay,
+  generateParamExample
+};

package/dist/chunk-XHPFY5MH.mjs

@@ -0,0 +1,132 @@
+// src/cli/core/display.ts
+import { spawn } from "child_process";
+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 } = await import("fs");
+    const { tmpdir } = await import("os");
+    const { join } = await import("path");
+    const tempPath = join(tmpdir(), `rainfall-image-${Date.now()}.png`);
+    const buffer = typeof imageData === "string" ? Buffer.from(imageData, "base64") : imageData;
+    writeFileSync(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 = 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 };
+}
+
+export {
+  detectImageSupport,
+  displayImage,
+  formatAsTable,
+  formatResult,
+  detectImageData
+};