@mediagraph/mcp 1.0.3 → 1.0.5

package/dist/index.js

@@ -1011,6 +1011,36 @@ var MediagraphClient = class {
   async addAssetsToUpload(guid, assetIds) {
     await this.request("POST", `/api/uploads/${guid}/assets`, { body: { asset_ids: assetIds } });
   }
+  /**
+   * Prepare an asset for upload - returns a signed URL for direct S3 upload
+   */
+  async prepareAssetUpload(uploadGuid, data) {
+    return this.request("POST", `/api/uploads/${uploadGuid}/assets`, {
+      body: { asset: data }
+    });
+  }
+  /**
+   * Mark an asset as uploaded (triggers processing)
+   */
+  async setAssetUploaded(assetGuid, skipMeta) {
+    const params = skipMeta ? { skip_meta: "true" } : void 0;
+    return this.request("GET", `/api/assets/${assetGuid}/set_uploaded`, { params });
+  }
+  /**
+   * Upload file data directly to a signed S3 URL
+   */
+  async uploadToSignedUrl(signedUrl, fileData, contentType) {
+    const response = await fetch(signedUrl, {
+      method: "PUT",
+      body: fileData,
+      headers: {
+        "Content-Type": contentType
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to upload to S3: ${response.status} ${response.statusText}`);
+    }
+  }
   async setUploadDone(id) {
     return this.request("POST", `/api/uploads/${id}/set_done`);
   }
@@ -2468,6 +2498,181 @@ var downloadTools = {
   }
 };
 
+// src/tools/uploads.ts
+import { readFile, stat } from "fs/promises";
+import { basename, extname } from "path";
+var MIME_TYPES = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff",
+  ".heic": "image/heic",
+  ".heif": "image/heif",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".avi": "video/x-msvideo",
+  ".webm": "video/webm",
+  ".mkv": "video/x-matroska",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".aac": "audio/aac",
+  ".flac": "audio/flac",
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".zip": "application/zip",
+  ".psd": "image/vnd.adobe.photoshop",
+  ".ai": "application/postscript",
+  ".eps": "application/postscript",
+  ".raw": "image/x-raw",
+  ".cr2": "image/x-canon-cr2",
+  ".nef": "image/x-nikon-nef",
+  ".arw": "image/x-sony-arw",
+  ".dng": "image/x-adobe-dng"
+};
+function getMimeType(filename) {
+  const ext = extname(filename).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+var uploadTools = {
+  definitions: [
+    {
+      name: "upload_file",
+      description: `Upload a file from the local filesystem to Mediagraph.
+This creates a new asset in the user's Mediagraph library.
+Supports images, videos, audio, documents, and other media files.
+The file will be processed and thumbnails/previews generated automatically.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          file_path: {
+            type: "string",
+            description: "Absolute path to the file on the local filesystem"
+          },
+          storage_folder_id: {
+            type: "number",
+            description: "Optional: ID of the storage folder to upload into"
+          }
+        },
+        required: ["file_path"]
+      }
+    },
+    {
+      name: "upload_files",
+      description: `Upload multiple files from the local filesystem to Mediagraph.
+Creates new assets for each file in the user's Mediagraph library.
+All files are uploaded in a single upload session.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          file_paths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Array of absolute paths to files on the local filesystem"
+          },
+          storage_folder_id: {
+            type: "number",
+            description: "Optional: ID of the storage folder to upload into"
+          }
+        },
+        required: ["file_paths"]
+      }
+    }
+  ],
+  handlers: {
+    async upload_file(args, { client: client2 }) {
+      const filePath = args.file_path;
+      let fileStats;
+      try {
+        fileStats = await stat(filePath);
+      } catch {
+        return errorResult(`File not found: ${filePath}`);
+      }
+      if (!fileStats.isFile()) {
+        return errorResult(`Not a file: ${filePath}`);
+      }
+      const fileData = await readFile(filePath);
+      const filename = basename(filePath);
+      const contentType = getMimeType(filename);
+      const upload = await client2.createUpload();
+      const preparedAsset = await client2.prepareAssetUpload(upload.guid, {
+        filename,
+        file_size: fileStats.size,
+        created_via: "mcp"
+      });
+      await client2.uploadToSignedUrl(preparedAsset.signed_upload_url, fileData, contentType);
+      const asset = await client2.setAssetUploaded(preparedAsset.guid);
+      await client2.setUploadDone(upload.id);
+      return successResult({
+        message: `Successfully uploaded ${filename}`,
+        asset: {
+          id: asset.id,
+          guid: asset.guid,
+          filename: asset.filename,
+          file_size: asset.file_size,
+          mime_type: asset.mime_type
+        },
+        upload_guid: upload.guid
+      });
+    },
+    async upload_files(args, { client: client2 }) {
+      const filePaths = args.file_paths;
+      if (!filePaths || filePaths.length === 0) {
+        return errorResult("No files provided");
+      }
+      const upload = await client2.createUpload();
+      const results = [];
+      for (const filePath of filePaths) {
+        try {
+          const fileStats = await stat(filePath);
+          if (!fileStats.isFile()) {
+            results.push({ filename: filePath, success: false, error: "Not a file" });
+            continue;
+          }
+          const fileData = await readFile(filePath);
+          const filename = basename(filePath);
+          const contentType = getMimeType(filename);
+          const preparedAsset = await client2.prepareAssetUpload(upload.guid, {
+            filename,
+            file_size: fileStats.size,
+            created_via: "mcp"
+          });
+          await client2.uploadToSignedUrl(preparedAsset.signed_upload_url, fileData, contentType);
+          const asset = await client2.setAssetUploaded(preparedAsset.guid);
+          results.push({
+            filename,
+            success: true,
+            asset_id: asset.id,
+            asset_guid: asset.guid
+          });
+        } catch (error) {
+          results.push({
+            filename: basename(filePath),
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+      }
+      await client2.setUploadDone(upload.id);
+      const successCount = results.filter((r) => r.success).length;
+      return successResult({
+        message: `Uploaded ${successCount} of ${filePaths.length} files`,
+        upload_guid: upload.guid,
+        results
+      });
+    }
+  }
+};
+
 // src/tools/webhooks.ts
 var webhookTools = {
   definitions: [
@@ -2781,6 +2986,7 @@ var allToolModules = [
   workflowTools,
   socialTools,
   downloadTools,
+  uploadTools,
   webhookTools,
   adminTools
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mediagraph/mcp",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "MCP server for Mediagraph - Media Asset Management Platform",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",