@mediagraph/mcp 1.0.2 → 1.0.4

package/dist/index.js

@@ -69,10 +69,11 @@ var OAuthHandler = class {
     });
     return `${this.config.oauthUrl}/oauth/authorize?${params.toString()}`;
   }
+  callbackPromise = null;
   /**
-   * Start a local HTTP server to receive the OAuth callback
+   * Start the callback server and wait for it to be ready
    */
-  async waitForCallback() {
+  async startCallbackServer() {
     return new Promise((resolve, reject) => {
       this.callbackServer = createServer((req, res) => {
         const url = new URL2(req.url || "/", `http://localhost:${this.config.redirectPort}`);
@@ -93,7 +94,8 @@ var OAuthHandler = class {
               </html>
             `);
             this.stopCallbackServer();
-            reject(new Error(errorDescription || error));
+            this.callbackPromise?.reject(new Error(errorDescription || error));
+            this.callbackPromise = null;
             return;
           }
           if (!code || !state) {
@@ -108,7 +110,8 @@ var OAuthHandler = class {
               </html>
             `);
             this.stopCallbackServer();
-            reject(new Error("Missing authorization code or state"));
+            this.callbackPromise?.reject(new Error("Missing authorization code or state"));
+            this.callbackPromise = null;
             return;
           }
           if (state !== this.state) {
@@ -123,7 +126,8 @@ var OAuthHandler = class {
               </html>
             `);
             this.stopCallbackServer();
-            reject(new Error("State parameter mismatch"));
+            this.callbackPromise?.reject(new Error("State parameter mismatch"));
+            this.callbackPromise = null;
             return;
           }
           res.writeHead(200, { "Content-Type": "text/html" });
@@ -137,20 +141,43 @@ var OAuthHandler = class {
             </html>
           `);
           this.stopCallbackServer();
-          resolve({ code, state });
+          this.callbackPromise?.resolve({ code, state });
+          this.callbackPromise = null;
         } else {
           res.writeHead(404);
           res.end("Not found");
         }
       });
+      this.callbackServer.on("error", (err) => {
+        reject(err);
+      });
       this.callbackServer.listen(this.config.redirectPort, () => {
+        resolve();
       });
+    });
+  }
+  /**
+   * Wait for the OAuth callback (server must be started first)
+   */
+  async waitForCallback() {
+    return new Promise((resolve, reject) => {
+      this.callbackPromise = { resolve, reject };
       setTimeout(() => {
-        this.stopCallbackServer();
-        reject(new Error("Authorization timed out"));
+        if (this.callbackPromise) {
+          this.stopCallbackServer();
+          this.callbackPromise.reject(new Error("Authorization timed out"));
+          this.callbackPromise = null;
+        }
       }, 5 * 60 * 1e3);
     });
   }
+  /**
+   * Start server and wait for callback (convenience method for CLI)
+   */
+  async startAndWaitForCallback() {
+    await this.startCallbackServer();
+    return this.waitForCallback();
+  }
   /**
    * Stop the callback server
    */
@@ -984,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`);
   }
@@ -2441,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,
+          content_type: asset.content_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: [
@@ -2754,6 +2986,7 @@ var allToolModules = [
   workflowTools,
   socialTools,
   downloadTools,
+  uploadTools,
   webhookTools,
   adminTools
 ];
@@ -2962,6 +3195,7 @@ async function runAutoAuth() {
   isAuthInProgress = true;
   try {
     const authUrl = oauthHandler.getAuthorizationUrl();
+    await oauthHandler.startCallbackServer();
     openBrowser(authUrl);
     const { code } = await oauthHandler.waitForCallback();
     const tokens = await oauthHandler.exchangeCode(code);
@@ -2978,6 +3212,7 @@ async function runAutoAuth() {
     return true;
   } catch (error) {
     console.error("Auto-auth failed:", error);
+    oauthHandler.stopCallbackServer();
     return false;
   } finally {
     isAuthInProgress = false;
@@ -3131,7 +3366,10 @@ async function runAuthorize() {
   console.log("Starting Mediagraph OAuth authorization...");
   console.log("");
   const authUrl = oauthHandler.getAuthorizationUrl();
-  console.log("Please open this URL in your browser:");
+  await oauthHandler.startCallbackServer();
+  openBrowser(authUrl);
+  console.log("Opening browser for authorization...");
+  console.log("If the browser does not open, please visit:");
   console.log("");
   console.log(authUrl);
   console.log("");

package/package.json

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