test

package.json

@@ -41,10 +41,13 @@
     "cheerio": "^1.1.2",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
+    "crypto-js": "^4.2.0",
     "express": "^5.2.1",
+    "file-type": "^21.3.0",
     "form-data": "^4.0.5",
     "framer-motion": "^12.26.2",
     "lucide-react": "^0.562.0",
+    "multer": "^2.0.2",
     "prismjs": "^1.30.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3",

src/client/hooks/usePlugin.ts

@@ -1,14 +1,22 @@
 import { useState, useEffect } from "react";
 
+export interface FileConstraints {
+  maxSize?: number;
+  acceptedTypes?: string[];
+  acceptedExtensions?: string[];
+}
+
 export interface PluginParameter {
   name: string;
-  type: "string" | "number" | "boolean" | "array" | "object";
+  type: "string" | "number" | "boolean" | "array" | "object" | "file";
   required: boolean;
   description: string;
   example?: any;
   default?: any;
   enum?: any[];
   pattern?: string;
+  fileConstraints?: FileConstraints;
+  acceptUrl?: boolean;
 }
 
 export interface PluginResponse {
@@ -37,6 +45,10 @@ export interface PluginMetadata {
   responses?: {
     [statusCode: number]: PluginResponse;
   };
+  disabled?: boolean;
+  deprecated?: boolean;
+  disabledReason?: string;
+  deprecatedReason?: string;
 }
 
 export interface ApiStats {

src/components/FileUpload.tsx

@@ -0,0 +1,284 @@
+import { useState, useRef, useCallback } from "react";
+import { Upload, X, File, AlertCircle, Link as LinkIcon } from "lucide-react";
+import { Input } from "@/components/ui/input";
+import { Button } from "@/components/ui/button";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { FileConstraints } from "@/server/types/plugin";
+
+interface FileUploadProps {
+  name: string;
+  description: string;
+  fileConstraints?: FileConstraints;
+  acceptUrl?: boolean;
+  onFileChange: (file: File | null) => void;
+  onUrlChange?: (url: string) => void;
+  disabled?: boolean;
+}
+
+export function FileUpload({
+  name,
+  description,
+  fileConstraints,
+  acceptUrl = false,
+  onFileChange,
+  onUrlChange,
+  disabled = false,
+}: FileUploadProps) {
+  const [selectedFile, setSelectedFile] = useState<File | null>(null);
+  const [fileUrl, setFileUrl] = useState<string>("");
+  const [error, setError] = useState<string | null>(null);
+  const [dragActive, setDragActive] = useState(false);
+  const [mode, setMode] = useState<"upload" | "url">("upload");
+  const fileInputRef = useRef<HTMLInputElement>(null);
+
+  const formatFileSize = (bytes: number): string => {
+    if (bytes === 0) return "0 Bytes";
+    const k = 1024;
+    const sizes = ["Bytes", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + " " + sizes[i];
+  };
+
+  const validateFile = (file: File): string | null => {
+    if (!fileConstraints) return null;
+    
+    if (fileConstraints.maxSize && file.size > fileConstraints.maxSize) {
+      return `File size (${formatFileSize(file.size)}) exceeds maximum allowed size (${formatFileSize(fileConstraints.maxSize)})`;
+    }
+
+    if (fileConstraints.acceptedTypes && fileConstraints.acceptedTypes.length > 0) {
+      if (!fileConstraints.acceptedTypes.includes(file.type)) {
+        return `File type ${file.type} is not accepted. Allowed types: ${fileConstraints.acceptedTypes.join(", ")}`;
+      }
+    }
+
+    if (fileConstraints.acceptedExtensions && fileConstraints.acceptedExtensions.length > 0) {
+      const extension = "." + file.name.split(".").pop()?.toLowerCase();
+      if (!fileConstraints.acceptedExtensions.includes(extension)) {
+        return `File extension ${extension} is not accepted. Allowed extensions: ${fileConstraints.acceptedExtensions.join(", ")}`;
+      }
+    }
+
+    return null;
+  };
+
+  const handleFileSelect = useCallback((file: File) => {
+    const validationError = validateFile(file);
+    
+    if (validationError) {
+      setError(validationError);
+      setSelectedFile(null);
+      onFileChange(null);
+      return;
+    }
+
+    setError(null);
+    setSelectedFile(file);
+    onFileChange(file);
+  }, [fileConstraints, onFileChange]);
+
+  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0];
+    if (file) {
+      handleFileSelect(file);
+    }
+  };
+
+  const handleDrag = (e: React.DragEvent) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (e.type === "dragenter" || e.type === "dragover") {
+      setDragActive(true);
+    } else if (e.type === "dragleave") {
+      setDragActive(false);
+    }
+  };
+
+  const handleDrop = (e: React.DragEvent) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setDragActive(false);
+
+    if (e.dataTransfer.files && e.dataTransfer.files[0]) {
+      handleFileSelect(e.dataTransfer.files[0]);
+    }
+  };
+
+  const handleRemoveFile = () => {
+    setSelectedFile(null);
+    setError(null);
+    onFileChange(null);
+    if (fileInputRef.current) {
+      fileInputRef.current.value = "";
+    }
+  };
+
+  const handleUrlChange = (url: string) => {
+    setFileUrl(url);
+    if (onUrlChange) {
+      onUrlChange(url);
+    }
+  };
+
+  const getAcceptAttribute = (): string | undefined => {
+    if (!fileConstraints) return undefined;
+    
+    const types = [];
+    if (fileConstraints.acceptedTypes) {
+      types.push(...fileConstraints.acceptedTypes);
+    }
+    if (fileConstraints.acceptedExtensions) {
+      types.push(...fileConstraints.acceptedExtensions);
+    }
+    
+    return types.length > 0 ? types.join(",") : undefined;
+  };
+
+  const renderContent = () => {
+    if (!acceptUrl) {
+      return (
+        <div className="space-y-3">
+          {renderUploadArea()}
+          {renderConstraints()}
+        </div>
+      );
+    }
+
+    return (
+      <Tabs value={mode} onValueChange={(v) => setMode(v as "upload" | "url")} className="w-full">
+        <TabsList className="grid w-full grid-cols-2 bg-black/30">
+          <TabsTrigger value="upload" className="data-[state=active]:bg-purple-500/20">
+            <Upload className="w-4 h-4 mr-2" />
+            Upload File
+          </TabsTrigger>
+          <TabsTrigger value="url" className="data-[state=active]:bg-purple-500/20">
+            <LinkIcon className="w-4 h-4 mr-2" />
+            Use URL
+          </TabsTrigger>
+        </TabsList>
+
+        <TabsContent value="upload" className="mt-3 space-y-3">
+          {renderUploadArea()}
+          {renderConstraints()}
+        </TabsContent>
+
+        <TabsContent value="url" className="mt-3 space-y-3">
+          <Input
+            type="url"
+            placeholder="https://example.com/file.jpg"
+            value={fileUrl}
+            onChange={(e) => handleUrlChange(e.target.value)}
+            disabled={disabled}
+            className="bg-black/50 border-white/10 text-white focus:border-purple-500"
+          />
+          <p className="text-xs text-gray-500">
+            Enter the URL of the file you want to process
+          </p>
+          {renderConstraints()}
+        </TabsContent>
+      </Tabs>
+    );
+  };
+
+  const renderUploadArea = () => (
+    <>
+      <div
+        className={`relative border-2 border-dashed rounded-lg p-8 transition-all ${
+          dragActive
+            ? "border-purple-500 bg-purple-500/10"
+            : "border-white/20 bg-black/30"
+        } ${disabled ? "opacity-50 cursor-not-allowed" : "cursor-pointer hover:border-purple-500/50"}`}
+        onDragEnter={handleDrag}
+        onDragLeave={handleDrag}
+        onDragOver={handleDrag}
+        onDrop={handleDrop}
+        onClick={() => !disabled && fileInputRef.current?.click()}
+      >
+        <input
+          ref={fileInputRef}
+          type="file"
+          onChange={handleFileChange}
+          accept={getAcceptAttribute()}
+          disabled={disabled}
+          className="hidden"
+        />
+
+        {selectedFile ? (
+          <div className="flex items-center justify-between">
+            <div className="flex items-center gap-3">
+              <div className="p-2 bg-purple-500/20 rounded">
+                <File className="w-6 h-6 text-purple-400" />
+              </div>
+              <div>
+                <p className="text-sm font-medium text-white">{selectedFile.name}</p>
+                <p className="text-xs text-gray-400">{formatFileSize(selectedFile.size)}</p>
+              </div>
+            </div>
+            <Button
+              type="button"
+              variant="ghost"
+              size="sm"
+              onClick={(e) => {
+                e.stopPropagation();
+                handleRemoveFile();
+              }}
+              disabled={disabled}
+              className="text-red-400 hover:text-red-300 hover:bg-red-500/10"
+            >
+              <X className="w-4 h-4" />
+            </Button>
+          </div>
+        ) : (
+          <div className="text-center">
+            <Upload className="w-12 h-12 text-gray-400 mx-auto mb-3" />
+            <p className="text-sm text-gray-300 mb-1">
+              {dragActive ? "Drop file here" : "Click to upload or drag and drop"}
+            </p>
+            <p className="text-xs text-gray-500">{description}</p>
+          </div>
+        )}
+      </div>
+
+      {error && (
+        <div className="flex items-start gap-2 p-3 bg-red-500/10 border border-red-500/30 rounded-lg">
+          <AlertCircle className="w-5 h-5 text-red-400 flex-shrink-0 mt-0.5" />
+          <p className="text-sm text-red-300">{error}</p>
+        </div>
+      )}
+    </>
+  );
+
+  const renderConstraints = () => {
+    if (!fileConstraints) return null;
+
+    return (
+      <div className="space-y-2">
+        {fileConstraints.maxSize && (
+          <p className="text-xs text-gray-500">
+            • Max file size: {formatFileSize(fileConstraints.maxSize)}
+          </p>
+        )}
+        {fileConstraints.acceptedTypes && fileConstraints.acceptedTypes.length > 0 && (
+          <p className="text-xs text-gray-500">
+            • Accepted types: {fileConstraints.acceptedTypes.join(", ")}
+          </p>
+        )}
+        {fileConstraints.acceptedExtensions && fileConstraints.acceptedExtensions.length > 0 && (
+          <p className="text-xs text-gray-500">
+            • Accepted extensions: {fileConstraints.acceptedExtensions.join(", ")}
+          </p>
+        )}
+      </div>
+    );
+  };
+
+  return (
+    <div className="space-y-2">
+      <label className="block text-sm text-gray-300">
+        {name}
+        <span className="text-xs text-gray-500 ml-2">(file)</span>
+      </label>
+      {renderContent()}
+    </div>
+  );
+}

src/components/PluginCard.tsx

@@ -8,6 +8,7 @@ import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import { PluginMetadata } from "@/client/hooks/usePlugin";
 import { Play, ChevronDown, ChevronUp, Copy, Check, AlertTriangle, XCircle } from "lucide-react";
 import { CodeBlock } from "@/components/CodeBlock";
+import { FileUpload } from "@/components/FileUpload";
 import { getApiUrl } from "@/lib/api-url";
 
 interface PluginCardProps {
@@ -24,6 +25,8 @@ const methodColors: Record<string, string> = {
 
 export function PluginCard({ plugin }: PluginCardProps) {
   const [paramValues, setParamValues] = useState<Record<string, string>>({});
+  const [fileParams, setFileParams] = useState<Record<string, File | null>>({});
+  const [urlParams, setUrlParams] = useState<Record<string, string>>({});
   const [response, setResponse] = useState<any>(null);
   const [responseHeaders, setResponseHeaders] = useState<Record<string, string>>({});
   const [requestUrl, setRequestUrl] = useState<string>("");
@@ -39,6 +42,14 @@ export function PluginCard({ plugin }: PluginCardProps) {
     setParamValues((prev) => ({ ...prev, [paramName]: value }));
   };
 
+  const handleFileChange = (paramName: string, file: File | null) => {
+    setFileParams((prev) => ({ ...prev, [paramName]: file }));
+  };
+
+  const handleUrlParamChange = (paramName: string, url: string) => {
+    setUrlParams((prev) => ({ ...prev, [paramName]: url }));
+  };
+  
   const handleExecute = async () => {
     if (isDisabled) {
       setResponse({
@@ -59,12 +70,23 @@ export function PluginCard({ plugin }: PluginCardProps) {
       let url = "/api" + plugin.endpoint;
       let fullUrl = getApiUrl(plugin.endpoint);
 
+      // Check if we have any file parameters
+      const hasFiles = Object.values(fileParams).some(file => file !== null);
+      const hasUrls = Object.values(urlParams).some(url => url !== "");
+
       if (plugin.method === "GET" && plugin.parameters?.query) {
         const queryParams = new URLSearchParams();
         plugin.parameters.query.forEach((param) => {
-          const value = paramValues[param.name];
-          if (value) {
-            queryParams.append(param.name, value);
+          if (param.type === "file" && param.acceptUrl) {
+            const urlValue = urlParams[param.name];
+            if (urlValue) {
+              queryParams.append(param.name, urlValue);
+            }
+          } else {
+            const value = paramValues[param.name];
+            if (value) {
+              queryParams.append(param.name, value);
+            }
           }
         });
 
@@ -80,7 +102,34 @@ export function PluginCard({ plugin }: PluginCardProps) {
         method: plugin.method,
       };
 
-      if (["POST", "PUT", "PATCH"].includes(plugin.method) && plugin.parameters?.body) {
+      if (hasFiles || (hasUrls && plugin.method !== "GET")) {
+        const formData = new FormData();
+
+        Object.entries(fileParams).forEach(([name, file]) => {
+          if (file) {
+            formData.append(name, file);
+          }
+        });
+
+        Object.entries(urlParams).forEach(([name, url]) => {
+          if (url && !fileParams[name]) {
+            formData.append(name, url);
+          }
+        });
+
+        if (plugin.parameters?.body) {
+          plugin.parameters.body.forEach((param) => {
+            if (param.type !== "file") {
+              const value = paramValues[param.name];
+              if (value) {
+                formData.append(param.name, value);
+              }
+            }
+          });
+        }
+
+        fetchOptions.body = formData;
+      } else if (["POST", "PUT", "PATCH"].includes(plugin.method) && plugin.parameters?.body) {
         const bodyData: Record<string, any> = {};
         plugin.parameters.body.forEach((param) => {
           const value = paramValues[param.name];
@@ -94,13 +143,53 @@ export function PluginCard({ plugin }: PluginCardProps) {
         };
       }
 
-      const res = await fetch(url, fetchOptions);
-      const data = await res.json();
+      // Add XMLHttpRequest fallback for FormData to avoid HTTP/2 issues
+      let res;
+      let data;
+      
+      if (fetchOptions.body instanceof FormData) {
+        // Use XMLHttpRequest for FormData to ensure compatibility
+        const xhr = new XMLHttpRequest();
+        
+        const xhrPromise = new Promise((resolve, reject) => {
+          xhr.onload = () => {
+            try {
+              const responseData = JSON.parse(xhr.responseText);
+              resolve({
+                status: xhr.status,
+                statusText: xhr.statusText,
+                headers: new Headers(),
+                json: async () => responseData
+              });
+            } catch (e) {
+              reject(new Error('Failed to parse response'));
+            }
+          };
+          
+          xhr.onerror = () => reject(new Error('Network request failed'));
+          xhr.ontimeout = () => reject(new Error('Request timeout'));
+          
+          xhr.open(plugin.method, url, true);
+          xhr.timeout = 60000; // 60 second timeout
+          xhr.send(fetchOptions.body as FormData);
+        });
+        
+        res = await xhrPromise as any;
+        data = await res.json();
+      } else {
+        // Use fetch for non-FormData requests
+        res = await fetch(url, fetchOptions);
+        data = await res.json();
+      }
 
       const headers: Record<string, string> = {};
-      res.headers.forEach((value, key) => {
-        headers[key] = value;
-      });
+      
+      // Get headers from Response object
+      if (res.headers && typeof res.headers.forEach === 'function') {
+        res.headers.forEach((value: string, key: string) => {
+          headers[key] = value;
+        });
+      }
 
       setResponseHeaders(headers);
       setResponse({
@@ -134,6 +223,20 @@ export function PluginCard({ plugin }: PluginCardProps) {
   };
 
   const renderParameterInput = (param: any) => {
+    if (param.type === "file") {
+      return (
+        <FileUpload
+          name={param.name}
+          description={param.description}
+          fileConstraints={param.fileConstraints}
+          acceptUrl={param.acceptUrl}
+          onFileChange={(file) => handleFileChange(param.name, file)}
+          onUrlChange={param.acceptUrl ? (url) => handleUrlParamChange(param.name, url) : undefined}
+          disabled={isDisabled}
+        />
+      );
+    }
+
     if (param.enum && Array.isArray(param.enum) && param.enum.length > 0) {
       return (
         <Select
@@ -157,18 +260,18 @@ export function PluginCard({ plugin }: PluginCardProps) {
           </SelectContent>
         </Select>
       );
-    } else {
-      return (
-        <Input
-          type="text"
-          placeholder={param.example?.toString() || param.description}
-          value={paramValues[param.name] || ""}
-          onChange={(e) => handleParamChange(param.name, e.target.value)}
-          disabled={isDisabled}
-          className="bg-black/50 border-white/10 text-white focus:border-purple-500 disabled:opacity-50"
-        />
-      );
     }
+
+    return (
+      <Input
+        type="text"
+        placeholder={param.example?.toString() || param.description}
+        value={paramValues[param.name] || ""}
+        onChange={(e) => handleParamChange(param.name, e.target.value)}
+        disabled={isDisabled}
+        className="bg-black/50 border-white/10 text-white focus:border-purple-500 disabled:opacity-50"
+      />
+    );
   };
 
   const hasQueryParams = plugin.parameters?.query && plugin.parameters.query.length > 0;
@@ -181,7 +284,12 @@ export function PluginCard({ plugin }: PluginCardProps) {
 
     if (hasQueryParams) {
       const exampleParams = plugin.parameters!.query!
-        .map((p) => `${p.name}=${p.example || 'value'}`)
+        .map((p) => {
+          if (p.type === "file" && p.acceptUrl) {
+            return `${p.name}=https://example.com/file.jpg`;
+          }
+          return `${p.name}=${p.example || 'value'}`;
+        })
         .join('&');
       curl += `?${exampleParams}`;
     }
@@ -189,31 +297,80 @@ export function PluginCard({ plugin }: PluginCardProps) {
     curl += '"';
 
     if (hasBodyParams) {
-      curl += ' \\\n  -H "Content-Type: application/json" \\\n  -d \'';
-      const bodyExample: Record<string, any> = {};
-      plugin.parameters!.body!.forEach((p) => {
-        bodyExample[p.name] = p.example || 'value';
-      });
-      curl += JSON.stringify(bodyExample, null, 2);
-      curl += "'";
+      const hasFileParams = plugin.parameters!.body!.some(p => p.type === "file");
+      
+      if (hasFileParams) {
+        curl += ' \\\n';
+        plugin.parameters!.body!.forEach((p) => {
+          if (p.type === "file") {
+            if (p.acceptUrl) {
+              curl += `  -F "${p.name}=https://example.com/file.jpg" \\\n`;
+            } else {
+              curl += `  -F "${p.name}=@/path/to/file" \\\n`;
+            }
+          } else {
+            curl += `  -F "${p.name}=${p.example || 'value'}" \\\n`;
+          }
+        });
+        curl = curl.slice(0, -3); // Remove last \\\n
+      } else {
+        curl += ' \\\n  -H "Content-Type: application/json" \\\n  -d \'';
+        const bodyExample: Record<string, any> = {};
+        plugin.parameters!.body!.forEach((p) => {
+          bodyExample[p.name] = p.example || 'value';
+        });
+        curl += JSON.stringify(bodyExample, null, 2);
+        curl += "'";
+      }
     }
 
     return curl;
   };
 
   const generateNodeExample = () => {
+    const hasFileParams = plugin.parameters?.body?.some(p => p.type === "file") || false;
+
+    if (hasFileParams) {
+      let code = 'const formData = new FormData();\n';
+      
+      plugin.parameters!.body!.forEach((p) => {
+        if (p.type === "file") {
+          if (p.acceptUrl) {
+            code += `formData.append("${p.name}", "https://example.com/file.jpg");\n`;
+          } else {
+            code += `// For file upload from input: <input type="file" id="fileInput">\n`;
+            code += `const fileInput = document.getElementById("fileInput");\n`;
+            code += `formData.append("${p.name}", fileInput.files[0]);\n`;
+          }
+        } else {
+          code += `formData.append("${p.name}", "${p.example || 'value'}");\n`;
+        }
+      });
+
+      code += `\nconst response = await fetch("${getApiUrl(plugin.endpoint)}", {\n`;
+      code += `  method: "${plugin.method}",\n`;
+      code += `  body: formData\n`;
+      code += '});\n\nconst data = await response.json();\nconsole.log(data);';
+      return code;
+    }
+
     let code = `const response = await fetch("${getApiUrl(plugin.endpoint)}`;
 
     if (hasQueryParams) {
       const exampleParams = plugin.parameters!.query!
-        .map((p) => `${p.name}=${p.example || 'value'}`)
+        .map((p) => {
+          if (p.type === "file" && p.acceptUrl) {
+            return `${p.name}=https://example.com/file.jpg`;
+          }
+          return `${p.name}=${p.example || 'value'}`;
+        })
         .join('&');
       code += `?${exampleParams}`;
     }
 
     code += '", {\n  method: "' + plugin.method + '"';
 
-    if (hasBodyParams) {
+    if (hasBodyParams && !hasFileParams) {
       code += ',\n  headers: {\n    "Content-Type": "application/json"\n  },\n  body: JSON.stringify(';
       const bodyExample: Record<string, any> = {};
       plugin.parameters!.body!.forEach((p) => {
@@ -229,7 +386,7 @@ export function PluginCard({ plugin }: PluginCardProps) {
 
   return (
     <Card className={`bg-white/[0.02] border-white/10 overflow-hidden w-full ${isDisabled ? 'opacity-60' : ''}`}>
-      {/* Collapsible Header */}
+      {/* Header */}
       <div
         className="p-4 border-b border-white/10 cursor-pointer hover:bg-white/[0.02] transition-colors"
         onClick={() => setIsExpanded(!isExpanded)}
@@ -240,7 +397,6 @@ export function PluginCard({ plugin }: PluginCardProps) {
           </Badge>
           <code className="text-sm text-purple-400 font-mono flex-1 min-w-0 break-all">{plugin.endpoint}</code>
           
-          {/* Status Badges */}
           {isDisabled && (
             <Badge className="bg-red-500/20 text-red-400 border-red-500/50 border flex items-center gap-1 flex-shrink-0">
               <XCircle className="w-3 h-3" />
@@ -290,7 +446,6 @@ export function PluginCard({ plugin }: PluginCardProps) {
           <h3 className="text-xl font-bold text-white mb-2">{plugin.name}</h3>
           <p className="text-gray-400 text-sm leading-relaxed">{plugin.description || "No description provided"}</p>
 
-          {/* Disabled/Deprecated Warnings */}
           {isDisabled && plugin.disabledReason && (
             <div className="mt-3 p-3 bg-red-500/10 border border-red-500/30 rounded-lg flex items-start gap-2">
               <XCircle className="w-5 h-5 text-red-400 flex-shrink-0 mt-0.5" />
@@ -311,7 +466,6 @@ export function PluginCard({ plugin }: PluginCardProps) {
             </div>
           )}
 
-          {/* Tags */}
           {plugin.tags && plugin.tags.length > 0 && (
             <div className="flex flex-wrap gap-2 mt-3">
               {plugin.tags.map((tag) => (
@@ -322,7 +476,6 @@ export function PluginCard({ plugin }: PluginCardProps) {
             </div>
           )}
 
-          {/* API URL Display */}
           <div className="mt-3 flex items-start gap-2">
             <span className="text-xs text-gray-500 flex-shrink-0">API URL:</span>
             <code className="text-xs text-gray-300 bg-black/30 px-2 py-1 rounded break-all flex-1">
@@ -352,7 +505,6 @@ export function PluginCard({ plugin }: PluginCardProps) {
 
           {/* Documentation Tab */}
           <TabsContent value="documentation" className="p-6 space-y-6">
-            {/* Parameters Table */}
             {hasAnyParams && (
               <div>
                 <h4 className="text-purple-400 font-semibold mb-3">Parameters</h4>
@@ -367,30 +519,25 @@ export function PluginCard({ plugin }: PluginCardProps) {
                       </tr>
                     </thead>
                     <tbody>
-                      {plugin.parameters?.path?.map((param) => (
+                      {[...(plugin.parameters?.path || []), ...(plugin.parameters?.query || []), ...(plugin.parameters?.body || [])].map((param) => (
                         <tr key={param.name} className="border-b border-white/5">
                           <td className="py-3 pr-4 text-white font-mono">{param.name}</td>
                           <td className="py-3 pr-4">
                             <span className="text-blue-400 font-mono text-xs">{param.type}</span>
-                            {param.enum && (
-                              <span className="ml-2 text-xs text-gray-500">
-                                (options: {param.enum.join(', ')})
-                              </span>
+                            {param.type === "file" && param.fileConstraints && (
+                              <div className="mt-1 space-y-1">
+                                {param.fileConstraints.maxSize && (
+                                  <div className="text-xs text-gray-500">
+                                    Max: {(param.fileConstraints.maxSize / 1024 / 1024).toFixed(1)}MB
+                                  </div>
+                                )}
+                                {param.fileConstraints.acceptedTypes && (
+                                  <div className="text-xs text-gray-500">
+                                    Types: {param.fileConstraints.acceptedTypes.join(', ')}
+                                  </div>
+                                )}
+                              </div>
                             )}
-                          </td>
-                          <td className="py-3 pr-4">
-                            <span className={param.required ? "text-red-400" : "text-gray-500"}>
-                              {param.required ? "Yes" : "No"}
-                            </span>
-                          </td>
-                          <td className="py-3 text-gray-400">{param.description}</td>
-                        </tr>
-                      ))}
-                      {plugin.parameters?.query?.map((param) => (
-                        <tr key={param.name} className="border-b border-white/5">
-                          <td className="py-3 pr-4 text-white font-mono">{param.name}</td>
-                          <td className="py-3 pr-4">
-                            <span className="text-blue-400 font-mono text-xs">{param.type}</span>
                             {param.enum && (
                               <span className="ml-2 text-xs text-gray-500">
                                 (options: {param.enum.join(', ')})
@@ -402,26 +549,14 @@ export function PluginCard({ plugin }: PluginCardProps) {
                               {param.required ? "Yes" : "No"}
                             </span>
                           </td>
-                          <td className="py-3 text-gray-400">{param.description}</td>
-                        </tr>
-                      ))}
-                      {plugin.parameters?.body?.map((param) => (
-                        <tr key={param.name} className="border-b border-white/5">
-                          <td className="py-3 pr-4 text-white font-mono">{param.name}</td>
-                          <td className="py-3 pr-4">
-                            <span className="text-blue-400 font-mono text-xs">{param.type}</span>
-                            {param.enum && (
-                              <span className="ml-2 text-xs text-gray-500">
-                                (options: {param.enum.join(', ')})
+                          <td className="py-3 text-gray-400">
+                            {param.description}
+                            {param.type === "file" && param.acceptUrl && (
+                              <span className="block mt-1 text-xs text-purple-400">
+                                ✓ Can also accept URL
                               </span>
                             )}
                           </td>
-                          <td className="py-3 pr-4">
-                            <span className={param.required ? "text-red-400" : "text-gray-500"}>
-                              {param.required ? "Yes" : "No"}
-                            </span>
-                          </td>
-                          <td className="py-3 text-gray-400">{param.description}</td>
                         </tr>
                       ))}
                     </tbody>
@@ -430,7 +565,7 @@ export function PluginCard({ plugin }: PluginCardProps) {
               </div>
             )}
 
-            {/* Responses */}
+            {/* Responses section */}
             {plugin.responses && Object.keys(plugin.responses).length > 0 && (
               <div>
                 <h4 className="text-purple-400 font-semibold mb-3">Responses</h4>
@@ -487,40 +622,27 @@ export function PluginCard({ plugin }: PluginCardProps) {
 
           {/* Try It Out Tab */}
           <TabsContent value="try" className="p-6">
-            {/* Parameters Input */}
             {hasAnyParams ? (
               <div className="space-y-4 mb-4">
-                {plugin.parameters?.query?.map((param) => (
+                {[...(plugin.parameters?.query || []), ...(plugin.parameters?.body || [])].map((param) => (
                   <div key={param.name}>
-                    <label className="block text-sm text-gray-300 mb-2">
-                      {param.name}
-                      {param.required && <span className="text-red-400 ml-1">*</span>}
-                      <span className="text-xs text-gray-500 ml-2">({param.type})</span>
-                      {param.enum && (
-                        <span className="text-xs text-purple-400 ml-2">
-                          • Select from options
-                        </span>
-                      )}
-                    </label>
-                    {renderParameterInput(param)}
-                    <p className="text-xs text-gray-500 mt-1">{param.description}</p>
-                  </div>
-                ))}
-
-                {plugin.parameters?.body?.map((param) => (
-                  <div key={param.name}>
-                    <label className="block text-sm text-gray-300 mb-2">
-                      {param.name}
-                      {param.required && <span className="text-red-400 ml-1">*</span>}
-                      <span className="text-xs text-gray-500 ml-2">({param.type})</span>
-                      {param.enum && (
-                        <span className="text-xs text-purple-400 ml-2">
-                          • Select from options
-                        </span>
-                      )}
-                    </label>
-                    {renderParameterInput(param)}
-                    <p className="text-xs text-gray-500 mt-1">{param.description}</p>
+                    {param.type !== "file" && (
+                      <>
+                        <label className="block text-sm text-gray-300 mb-2">
+                          {param.name}
+                          {param.required && <span className="text-red-400 ml-1">*</span>}
+                          <span className="text-xs text-gray-500 ml-2">({param.type})</span>
+                          {param.enum && (
+                            <span className="text-xs text-purple-400 ml-2">
+                              • Select from options
+                            </span>
+                          )}
+                        </label>
+                        {renderParameterInput(param)}
+                        <p className="text-xs text-gray-500 mt-1">{param.description}</p>
+                      </>
+                    )}
+                    {param.type === "file" && renderParameterInput(param)}
                   </div>
                 ))}
               </div>
@@ -528,7 +650,6 @@ export function PluginCard({ plugin }: PluginCardProps) {
               <p className="text-sm text-gray-400 mb-4">No parameters required</p>
             )}
 
-            {/* Execute Button */}
             <Button
               onClick={handleExecute}
               disabled={loading || isDisabled}
@@ -541,7 +662,6 @@ export function PluginCard({ plugin }: PluginCardProps) {
             {/* Response Display */}
             {response && (
               <div className="mt-6 space-y-4">
-                {/* Deprecation Warning in Response */}
                 {isDeprecated && responseHeaders['x-plugin-deprecated'] && (
                   <div className="p-3 bg-yellow-500/10 border border-yellow-500/30 rounded-lg flex items-start gap-2">
                     <AlertTriangle className="w-5 h-5 text-yellow-400 flex-shrink-0 mt-0.5" />
@@ -554,7 +674,6 @@ export function PluginCard({ plugin }: PluginCardProps) {
                   </div>
                 )}
 
-                {/* Request URL */}
                 {requestUrl && (
                   <div>
                     <div className="flex items-center justify-between mb-2">
@@ -577,7 +696,6 @@ export function PluginCard({ plugin }: PluginCardProps) {
                   </div>
                 )}
 
-                {/* Response Status */}
                 <div className="flex items-center justify-between">
                   <span className="text-sm text-gray-400">Response Status</span>
                   <Badge className={`${response.status >= 200 && response.status < 300
@@ -588,7 +706,6 @@ export function PluginCard({ plugin }: PluginCardProps) {
                   </Badge>
                 </div>
 
-                {/* Response Headers */}
                 {Object.keys(responseHeaders).length > 0 && (
                   <div>
                     <h5 className="text-sm text-gray-400 mb-2">Response Headers</h5>
@@ -603,7 +720,6 @@ export function PluginCard({ plugin }: PluginCardProps) {
                   </div>
                 )}
 
-                {/* Response Body */}
                 <div>
                   <h5 className="text-sm text-gray-400 mb-2">Response Body</h5>
                   <CodeBlock

src/server/index.ts

@@ -19,10 +19,11 @@ app.use(
     verify: (req, _res, buf) => {
       req.rawBody = buf;
     },
+    limit: '10mb'
   }),
 );
 
-app.use(express.urlencoded({ extended: false }));
+app.use(express.urlencoded({ limit: '10mb', extended: false }));
 
 export function log(message: string, source = "express") {
   const formattedTime = new Date().toLocaleTimeString("id-ID", {

src/server/plugins/ai/ai_image_editor.js

@@ -0,0 +1,264 @@
+import { sendSuccess, ErrorResponses } from "../../lib/response-helper.js";
+import { AIEnhancer } from "./ai_image_utils.js";
+import multer from "multer";
+import axios from "axios";
+import path from "path"; 
+
+const storage = multer.memoryStorage();
+const upload = multer({
+  storage: storage,
+  limits: {
+    fileSize: 5 * 1024 * 1024, // 5MB
+  },
+  fileFilter: (req, file, cb) => {
+    const allowedTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/webp'];
+    if (allowedTypes.includes(file.mimetype)) {
+      cb(null, true);
+    } else {
+      cb(new Error('Invalid file type. Only JPEG, PNG, GIF, and WebP are allowed.'));
+    }
+  }
+});
+
+const ModelMap = {
+  nano_banana: 2,
+  seed_dream: 5,
+  flux: 8,
+  qwen_image: 9
+};
+
+/** @type {import("../../types/plugin.ts").ApiPluginHandler}*/
+const handler = {
+  name: "AI Image Editor",
+  description: "Edit your images using AI",
+  method: "POST",
+  version: "1.0.0",
+  category: ["ai"],
+  alias: ["aiImageEditor"],
+  tags: ["ai", "image"],
+  parameters: {
+    body: [
+      {
+        name: "image",
+        type: "file",
+        required: true,
+        description: "Image file to edit (or URL)",
+        fileConstraints: {
+          maxSize: 5 * 1024 * 1024, // 5MB
+          acceptedTypes: ["image/jpeg", "image/png", "image/gif", "image/webp"],
+          acceptedExtensions: [".jpg", ".jpeg", ".png", ".gif", ".webp"]
+        },
+        acceptUrl: true
+      },
+      {
+        name: "model",
+        type: "string",
+        required: true,
+        description: "Select an AI model to edit your image.",
+        example: "nano_banana",
+        enum: ["nano_banana", "seed_dream", "flux", "qwen_image"],
+        default: "nano_banana"
+      },
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Tell AI how your image will look edited",
+        example: "Put Cristiano Ronaldo next to that person"
+      },
+      {
+        name: "output_size",
+        type: "string",
+        required: true,
+        description: "Output size",
+        example: "2K",
+        enum: ["2K", "4K", "8K"],
+        default: "2K"
+      },
+      {
+        name: "disable_safety_checker",
+        type: "boolean",
+        required: false,
+        description: "If you want to disable safety checker for indecent images, set to true (default false)",
+        example: false,
+        default: false
+      }
+    ]
+  },
+  responses: {
+    200: {
+      status: 200,
+      description: "Successfully retrieved data",
+      example: {
+        status: 200,
+        author: "Ditzzy",
+        note: "Thank you for using this API!",
+        results: {
+          image_url: "https://example.com/edited-image.jpg",
+          filename: "edited-image.jpg",
+          size: "2K"
+        }
+      }
+    },    
+    404: {
+      status: 404,
+      description: "Missing required parameter",
+      example: {
+        status: 404,
+        message: "Missing required parameter"
+      }
+    },
+    400: {
+      status: 400,
+      description: "Invalid file or URL",
+      example: {
+        success: false,
+        message: "Invalid image file or URL"
+      }
+    },
+    413: {
+      status: 413,
+      description: "File too large",
+      example: {
+        success: false,
+        message: "File size exceeds 5MB limit"
+      }
+    },
+    500: {
+      status: 500,
+      description: "Server error or unavailable",
+      example: {
+        status: 500,
+        message: "An error occurred, please try again later."
+      }
+    }
+  },
+  exec: async (req, res) => {
+    console.log("🔵 [1] Request received at AI Image Editor");
+    console.log("🔵 [1] Headers:", req.headers);
+    
+    upload.single('image')(req, res, async (err) => {
+      console.log("🔵 [2] Inside multer middleware");
+      
+      if (err) {
+        console.error("❌ [2] Multer error:", err);
+        if (err instanceof multer.MulterError) {
+          if (err.code === 'LIMIT_FILE_SIZE') {
+            return res.status(413).json({
+              success: false,
+              message: "File size exceeds 5MB limit"
+            });
+          }
+        }
+        return res.status(400).json({
+          success: false,
+          message: err.message || "File upload error"
+        });
+      }
+      
+      console.log("🔵 [3] Multer successful");
+      console.log("🔵 [3] Body:", req.body);
+      console.log("🔵 [3] File:", req.file ? `${req.file.originalname} (${req.file.size} bytes)` : "No file");
+      
+      try {
+        const { prompt, output_size, disable_safety_checker, model } = req.body;
+        
+        console.log("🔵 [4] Extracted params:", { prompt, output_size, model, disable_safety_checker });
+        
+        // Validate required parameters
+        if (!prompt) {
+          console.log("❌ [4] Missing prompt");
+          return ErrorResponses.missingParameter(res, "prompt");
+        }
+        if (!output_size) {
+          console.log("❌ [4] Missing output_size");
+          return ErrorResponses.missingParameter(res, "output_size");
+        }
+        if (!model) {
+          console.log("❌ [4] Missing model");
+          return ErrorResponses.missingParameter(res, "model");
+        }
+        
+        // Validate model
+        if (!ModelMap[model]) {
+          console.log("❌ [4] Invalid model:", model);
+          return res.status(400).json({
+            success: false,
+            message: `Invalid model. Must be one of: ${Object.keys(ModelMap).join(', ')}`
+          });
+        }
+        
+        console.log("🔵 [5] Creating AIEnhancer instance");
+        const ai = new AIEnhancer();
+        console.log("✅ [5] AIEnhancer created");
+        
+        let imageBuffer;
+        let filename;
+        
+        // Handle uploaded file
+        if (req.file) {
+          console.log("🔵 [6] Using uploaded file");
+          imageBuffer = req.file.buffer;
+          filename = req.file.originalname;
+        } 
+        // Handle URL
+        else if (req.body.image && typeof req.body.image === 'string') {
+          console.log("🔵 [6] Downloading from URL:", req.body.image);
+          const imageUrl = req.body.image;
+          
+          // Validate URL
+          try {
+            new URL(imageUrl);
+          } catch {
+            console.log("❌ [6] Invalid URL");
+            return ErrorResponses.invalidUrl(res, "Invalid image URL");
+          }
+          
+          // Download image from URL
+          const response = await axios.get(imageUrl, {
+            responseType: 'arraybuffer',
+            maxContentLength: 5 * 1024 * 1024,
+            timeout: 10000,
+            headers: {
+              'User-Agent': 'Mozilla/5.0 (compatible; AIImageEditor/1.0)'
+            }
+          });
+
+          imageBuffer = Buffer.from(response.data);
+          filename = path.basename(new URL(imageUrl).pathname) || 'image';
+          console.log("✅ [6] Downloaded from URL:", filename);
+        } else {
+          console.log("❌ [6] No image provided");
+          return ErrorResponses.missingParameter(res, "image (file or URL)");
+        }
+        
+        console.log("🔵 [7] Image buffer size:", imageBuffer.length);
+        
+        // Get model ID from map
+        const modelId = ModelMap[model];
+        console.log("🔵 [8] Model ID:", modelId);
+
+        // Call AI Image Editor
+        console.log("🔵 [9] Calling ImageAIEditor...");
+        const edit = await ai.ImageAIEditor(imageBuffer, modelId, {
+          size: output_size,
+          aspect_ratio: "match_input_image",
+          go_fast: true,
+          prompt: prompt,
+          output_quality: 100,
+          disable_safety_checker: disable_safety_checker === 'true' || disable_safety_checker === true,
+        });
+        
+        console.log("✅ [9] ImageAIEditor response:", edit);
+  
+        return sendSuccess(res, edit.results || edit);
+      } catch (e) {
+        console.error("❌ [ERROR] Exception caught:", e);
+        console.error("❌ [ERROR] Stack trace:", e.stack);
+        return ErrorResponses.serverError(res, "An error occurred, try again later.");
+      }
+    });
+  }
+}
+
+export default handler;

src/server/plugins/ai/ai_image_utils.js

@@ -0,0 +1,359 @@
+const ModelMap = {
+  nano_banana: 2,
+  seed_dream: 5,
+  flux: 8,
+  qwen_image: 9
+};
+
+const IMAGE_TO_ANIME_PRESETS = {
+  manga: {
+    size: "2K",
+    aspect_ratio: "match_input_image",
+    output_format: "jpg",
+    sequential_image_generation: "disabled",
+    max_images: 1,
+    prompt: "Convert the provided image into a KOREAN-STYLE MANGA illustration. Apply strong stylization with clear and noticeable differences from the original image."
+  },
+
+  anime: {
+    size: "2K",
+    aspect_ratio: "match_input_image",
+    output_format: "jpg",
+    sequential_image_generation: "disabled",
+    max_images: 1,
+    prompt: "Convert the provided image into an ANIME-STYLE illustration. Apply strong stylization with clear and noticeable differences from the original image."
+  },
+
+  ghibli: {
+    size: "2K",
+    aspect_ratio: "match_input_image",
+    output_format: "jpg",
+    sequential_image_generation: "disabled",
+    max_images: 1,
+    prompt: "Convert the provided image into a STUDIO GHIBLI-STYLE illustration. Apply strong stylization with clear and noticeable differences from the original image."
+  },
+
+  cyberpunk: {
+    size: "2K",
+    aspect_ratio: "match_input_image",
+    output_format: "jpg",
+    sequential_image_generation: "disabled",
+    max_images: 1,
+    prompt: "Convert the provided image into a CYBERPUNK-STYLE illustration with neon colors, futuristic elements, and dark atmosphere."
+  },
+
+  watercolor: {
+    size: "2K",
+    aspect_ratio: "match_input_image",
+    output_format: "png",
+    sequential_image_generation: "disabled",
+    max_images: 1,
+    prompt: "Convert the provided image into a WATERCOLOR painting style with soft brush strokes and pastel colors."
+  },
+
+  pixelart: {
+    size: "2K",
+    aspect_ratio: "match_input_image",
+    output_format: "png",
+    sequential_image_generation: "disabled",
+    max_images: 1,
+    prompt: "Convert the provided image into PIXEL ART style with 8-bit retro gaming aesthetic."
+  },
+
+  sketch: {
+    size: "2K",
+    aspect_ratio: "match_input_image",
+    output_format: "jpg",
+    sequential_image_generation: "disabled",
+    max_images: 1,
+    prompt: "Convert the provided image into a detailed PENCIL SKETCH with realistic shading and artistic strokes."
+  },
+
+  oilpainting: {
+    size: "2K",
+    aspect_ratio: "match_input_image",
+    output_format: "jpg",
+    sequential_image_generation: "disabled",
+    max_images: 1,
+    prompt: "Convert the provided image into an OIL PAINTING style with thick brush strokes and rich colors."
+  }
+};
+
+const IMAGE_TO_ANIME_ENCRYPTED_PAYLOADS = {
+  manga: "L7p91uXhVyp5OOJthAyqjSqhlbM+RPZ8+h2Uq9tz6Y+4Agarugz8f4JjxjEycxEzuj/7+6Q0YY9jUvrfmqkucENhHAkMq1EOilzosQlw2msQpW2yRqV3C/WqvP/jrmSu3aUVAyeFhSbK3ARzowBzQYPVHtxwBbTWwlSR4tehnodUasnmftnY77c8gIFtL2ArNdzmPLx5H8O9un2U8WE4s0+xiFV3y4sbetHMN7rHh7DRIpuIQD4rKISR/vE+HeaHpRavXfsilr5P7Y6bsIo+RRFIPgX2ofbYYiATziqsjDeie4IlcOAVf1Pudqz8uk6YKM78CGxjF9iPLYQnkW+c6j96PNsg1Yk4Xz8/ZcdmHF4GGZe8ILYH/D0yyM1dsCkK1zY8ciL+6pAk4dHIZ/4k9A==",
+  ghibli: "L7p91uXhVyp5OOJthAyqjSqhlbM+RPZ8+h2Uq9tz6Y+4Agarugz8f4JjxjEycxEzuj/7+6Q0YY9jUvrfmqkucENhHAkMq1EOilzosQlw2msQpW2yRqV3C/WqvP/jrmSu3aUVAyeFhSbK3ARzowBzQYPVHtxwBbTWwlSR4tehnodUasnmftnY77c8gIFtL2ArNdzmPLx5H8O9un2U8WE4syzL5EYHGJWC1rlQM9xhNe1PViOsBSxmwHVwOdqtxZtcAJmGuzTgG7JVU7Hr9ZRwajhYK5yxQwSdJGwwR4jjS1yF9s9wKUQqgI+fYxaw7FZziLS+9JG5pTEjch4D0fpl+LO7vIynHN4cyu4DDeAUwNeYfbGMn2QQs+5OgMdViCAM1GkJk2jhlQm10rESTjDryw==",
+  anime: "L7p91uXhVyp5OOJthAyqjSqhlbM+RPZ8+h2Uq9tz6Y+4Agarugz8f4JjxjEycxEzuj/7+6Q0YY9jUvrfmqkucENhHAkMq1EOilzosQlw2msQpW2yRqV3C/WqvP/jrmSu3aUVAyeFhSbK3ARzowBzQYPVHtxwBbTWwlSR4tehnodUasnmftnY77c8gIFtL2ArNdzmPLx5H8O9un2U8WE4s7O2FxvQPCjt2uGmHPMOx1DsNSnLvzCKPVdz8Ob1cPHePmmquQZlsb/p+8gGv+cizSiOL4ts6GD2RxWN+K5MmpA/F3rQXanFUm4EL0g7qZCQbChRRQyaAyZuxtIdTKsmsMzkVKM5Sx96eV7bEjUAJ52j6NcP96INv2DhnWTP7gB6tltFQe8B8SPS2LuLRuPghA=="
+};
+
+export class AIEnhancer {
+  constructor() {
+    this.CREATED_BY = "Ditzzy";
+    this.NOTE = "Thank you for using this scrape, I hope you appreciate me for making this scrape by not deleting wm";
+
+    this.AES_KEY = "ai-enhancer-web__aes-key";
+    this.AES_IV = "aienhancer-aesiv";
+
+    this.HEADERS = {
+      "accept": "*/*",
+      "content-type": "application/json",
+      "Referer": "https://aienhancer.ai",
+      "Referrer-Policy": "strict-origin-when-cross-origin"
+    };
+
+    this.POLLING_INTERVAL = 2000;
+    this.MAX_POLLING_ATTEMPTS = 120;
+  }
+
+  encrypt(data) {
+    const plaintext = typeof data === "string" ? data : JSON.stringify(data);
+
+    return CryptoJS.AES.encrypt(
+      plaintext,
+      CryptoJS.enc.Utf8.parse(this.AES_KEY),
+      {
+        iv: CryptoJS.enc.Utf8.parse(this.AES_IV),
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7
+      }
+    ).toString();
+  }
+
+  decrypt(encryptedData) {
+    const decrypted = CryptoJS.AES.decrypt(
+      encryptedData,
+      CryptoJS.enc.Utf8.parse(this.AES_KEY),
+      {
+        iv: CryptoJS.enc.Utf8.parse(this.AES_IV),
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7
+      }
+    );
+
+    return decrypted.toString(CryptoJS.enc.Utf8);
+  }
+
+  decryptToJSON(encryptedData) {
+    const decrypted = this.decrypt(encryptedData);
+    return JSON.parse(decrypted);
+  }
+
+  wrapResponse(data) {
+    return {
+      created_by: this.CREATED_BY,
+      note: this.NOTE,
+      results: data
+    };
+  }
+
+  async sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  async processImage(image) {
+    let img;
+    let type;
+
+    if (typeof image === "string") {
+      img = readFileSync(image);
+      type = await fileTypeFromBuffer(img);
+    } else if (Buffer.isBuffer(image)) {
+      img = image;
+      type = await fileTypeFromBuffer(image);
+    } else {
+      throw new Error("Invalid image input: must be file path (string) or Buffer");
+    }
+
+    if (!type) {
+      throw new Error("Could not detect file type");
+    }
+
+    const allowedImageTypes = [
+      'image/jpeg',
+      'image/jpg',
+      'image/png',
+      'image/webp',
+      'image/gif',
+      'image/bmp'
+    ];
+
+    if (!allowedImageTypes.includes(type.mime)) {
+      throw new Error(
+        `Unsupported format: ${type.mime}. Allowed: jpeg, jpg, png, webp, gif, bmp`
+      );
+    }
+
+    const imgbase64 = img.toString("base64");
+    return {
+      base64: `data:${type.mime};base64,${imgbase64}`,
+      mime: type.mime
+    };
+  }
+
+  async createTask(apiUrl, model, image, config) {
+    const { base64 } = await this.processImage(image);
+
+    const settings = typeof config === "string"
+      ? config
+      : this.encrypt(config);
+
+    const requestConfig = {
+      url: apiUrl,
+      method: "POST",
+      headers: this.HEADERS,
+      data: {
+        model,
+        image: base64,
+        settings
+      }
+    };
+
+    const { data } = await axios.request(requestConfig);
+
+    if (data.code !== 100000 || !data.data.id) {
+      throw new Error(`Task creation failed: ${data.message}`);
+    }
+
+    return data.data.id;
+  }
+
+  async checkTaskStatus(resultUrl, taskId) {
+    const config = {
+      url: resultUrl,
+      method: "POST",
+      headers: this.HEADERS,
+      data: { task_id: taskId }
+    };
+
+    const { data } = await axios.request(config);
+    return data;
+  }
+
+  async pollTaskResult(resultUrl, taskId) {
+    let attempts = 0;
+
+    while (attempts < this.MAX_POLLING_ATTEMPTS) {
+      const response = await this.checkTaskStatus(resultUrl, taskId);
+
+      if (response.code !== 100000) {
+        throw new Error(`Status check failed: ${response.message}`);
+      }
+
+      const { status, error, output, input, completed_at } = response.data;
+
+      if ((status === "succeeded" || status === "success") && output && input) {
+        return {
+          id: taskId,
+          output,
+          input,
+          error,
+          status,
+          created_at: response.data.created_at,
+          started_at: response.data.started_at,
+          completed_at: completed_at
+        };
+      }
+
+      if (status === "failed" || status === "fail" || error) {
+        throw new Error(`Task failed: ${error || "Unknown error"}`);
+      }
+
+      console.log(`[${taskId} | ${status}] Polling attempt ${attempts + 1}/${this.MAX_POLLING_ATTEMPTS}`);
+
+      await this.sleep(this.POLLING_INTERVAL);
+      attempts++;
+    }
+
+    throw new Error(`Task timeout after ${this.MAX_POLLING_ATTEMPTS} attempts`);
+  }
+
+  async imageToAnime(image, preset = "anime") {
+    try {
+      const apiUrl = "https://aienhancer.ai/api/v1/r/image-enhance/create";
+      const resultUrl = "https://aienhancer.ai/api/v1/r/image-enhance/result";
+      const model = 5;
+
+      let config;
+
+      if (typeof preset === "string") {
+        if (IMAGE_TO_ANIME_PRESETS[preset]) {
+          config = IMAGE_TO_ANIME_PRESETS[preset];
+        }
+        else if (IMAGE_TO_ANIME_ENCRYPTED_PAYLOADS[preset]) {
+          config = IMAGE_TO_ANIME_ENCRYPTED_PAYLOADS[preset];
+        }
+        else {
+          config = preset;
+        }
+      } else {
+        config = preset;
+      }
+
+      const taskId = await this.createTask(apiUrl, model, image, config);
+      console.log(`✓ Task created: ${taskId}`);
+
+      const result = await this.pollTaskResult(resultUrl, taskId);
+      return this.wrapResponse(result);
+    } catch (error) {
+      throw new Error(`Image to anime conversion failed: ${error}`);
+    }
+  }
+
+  async ImageAIEditor(image, model, preset) {
+    try {
+      const apiUrl = "https://aienhancer.ai/api/v1/k/image-enhance/create";
+      const resultUrl = "https://aienhancer.ai/api/v1/k/image-enhance/result";
+
+      const modelId = ModelMap[model];
+      const taskId = await this.createTask(apiUrl, modelId, image, preset);
+      const result = await this.pollTaskResult(resultUrl, taskId);
+
+      return this.wrapResponse(result);
+    } catch (e) {
+      throw new Error("Image editor failed: " + e);
+    }
+  }
+
+  async AIImageRestoration(image, model, config) {
+    try {
+      const apiUrl = "https://aienhancer.ai/api/v1/r/image-enhance/create";
+      const resultUrl = "https://aienhancer.ai/api/v1/r/image-enhance/result";
+
+      const taskId = await this.createTask(apiUrl, model, image, config);
+      const result = await this.pollTaskResult(resultUrl, taskId);
+
+      return this.wrapResponse(result);
+    } catch (e) {
+      throw new Error(`An error occurred while upscaling the image: ${e}`);
+    }
+  }
+
+  async RemoveBackground(image, config = {}) {
+    try {
+      const apiUrl = "https://aienhancer.ai/api/v1/r/image-enhance/create";
+      const resultUrl = "https://aienhancer.ai/api/v1/r/image-enhance/result";
+      const model = 4;
+
+      const payloadConfig = config ? config : {
+        threshold: 0,
+        reverse: false,
+        background_type: "rgba",
+        format: "png",
+      };
+
+      const taskId = await this.createTask(apiUrl, model, image, payloadConfig);
+      const result = await this.pollTaskResult(resultUrl, taskId);
+
+      return this.wrapResponse(result);
+    } catch (e) {
+      throw new Error(`Remove background error: ${e}`);
+    }
+  }
+
+  decryptPayload(encryptedPayload) {
+    return this.decryptToJSON(encryptedPayload);
+  }
+
+  encryptConfig(config) {
+    return this.encrypt(config);
+  }
+}

src/server/types/plugin.ts

@@ -1,14 +1,22 @@
 import { Request, Response, NextFunction } from "express";
 
+export interface FileConstraints {
+  maxSize?: number; // NOTE: in bytes, e.g., 5 * 1024 * 1024 for 5MB
+  acceptedTypes?: string[]; // NOTE: MIME types, e.g., ['image/jpeg', 'image/png']
+  acceptedExtensions?: string[]; // e.g., ['.jpg', '.png', '.pdf']
+}
+
 export interface PluginParameter {
   name: string;
-  type: "string" | "number" | "boolean" | "array" | "object";
+  type: "string" | "number" | "boolean" | "array" | "object" | "file";
   required: boolean;
   description: string;
   example?: any;
   default?: any;
   enum?: any[];
   pattern?: string;
+  fileConstraints?: FileConstraints;
+  acceptUrl?: boolean;
 }
 
 export interface PluginResponse {