@danainnovations/cortex-mcp 1.0.29 → 1.0.31

package/dist/cli.js

@@ -41,7 +41,7 @@ var AVAILABLE_MCPS = [
   {
     name: "m365",
     displayName: "Microsoft 365",
-    description: "Email, calendar, OneDrive, Teams, meetings (11 tools)",
+    description: "Email, calendar, OneDrive, Teams, meetings, contacts, tasks, notes (32 tools)",
     serverName: "cortex-m365",
     authMode: "personal"
   },
@@ -58,6 +58,20 @@ var AVAILABLE_MCPS = [
     description: "Boards, items, groups, updates, workspaces (18 tools)",
     serverName: "cortex-monday",
     authMode: "personal"
+  },
+  {
+    name: "slack",
+    displayName: "Slack",
+    description: "Messaging, channels, search, reactions, bookmarks (22 tools)",
+    serverName: "cortex-slack",
+    authMode: "personal"
+  },
+  {
+    name: "bestbuy",
+    displayName: "Best Buy",
+    description: "Product search, pricing, reviews, store locations (7 tools)",
+    serverName: "cortex-bestbuy",
+    authMode: "company"
   }
 ];
 var MCP_NAMES = AVAILABLE_MCPS.map((m) => m.name);
@@ -964,6 +978,7 @@ async function runConfigure(options) {
 }
 
 // src/proxy/stdio-server.ts
+import { readFileSync as readFileSync4, statSync } from "fs";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -1074,6 +1089,179 @@ var CortexHttpClient = class {
 };
 
 // src/proxy/stdio-server.ts
+var UPLOAD_TOOLS = /* @__PURE__ */ new Set(["upload_file", "upload_file_to_sharepoint"]);
+var INLINE_UPLOAD_MAX = 3.5 * 1024 * 1024;
+function overrideUploadToolSchema(tool) {
+  const name = tool.name;
+  const baseName = name.includes("__") ? name.split("__").pop() : name;
+  if (baseName === "upload_file") {
+    return {
+      ...tool,
+      description: "Upload a local file to the user's OneDrive. Provide the absolute local file path \u2014 the file is read and uploaded automatically. Works with any file size.",
+      inputSchema: {
+        type: "object",
+        required: ["file_path", "path"],
+        properties: {
+          file_path: {
+            type: "string",
+            description: "Absolute path to the local file to upload (e.g. '/Users/name/Documents/report.xlsx')"
+          },
+          path: {
+            type: "string",
+            description: "Destination path in OneDrive (e.g. 'Documents/report.xlsx')"
+          },
+          content_type: {
+            type: "string",
+            description: "MIME type. Defaults to 'application/octet-stream'"
+          }
+        }
+      }
+    };
+  }
+  if (baseName === "upload_file_to_sharepoint") {
+    return {
+      ...tool,
+      description: "Upload a local file to a SharePoint document library. Provide the absolute local file path \u2014 the file is read and uploaded automatically.",
+      inputSchema: {
+        type: "object",
+        required: ["file_path", "site_id", "path"],
+        properties: {
+          file_path: {
+            type: "string",
+            description: "Absolute path to the local file to upload"
+          },
+          site_id: {
+            type: "string",
+            description: "SharePoint site ID"
+          },
+          path: {
+            type: "string",
+            description: "Destination path in the site drive (e.g. 'Shared Documents/report.pdf')"
+          },
+          content_type: {
+            type: "string",
+            description: "MIME type. Defaults to 'application/octet-stream'"
+          }
+        }
+      }
+    };
+  }
+  return tool;
+}
+async function handleLocalFileUpload(cortex, toolName, args) {
+  const filePath = args.file_path;
+  let fileSize;
+  try {
+    fileSize = statSync(filePath).size;
+  } catch {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        success: false,
+        error: `File not found: ${filePath}`
+      }) }],
+      isError: true
+    };
+  }
+  if (fileSize <= INLINE_UPLOAD_MAX) {
+    const fileBuffer2 = readFileSync4(filePath);
+    const base64Content = fileBuffer2.toString("base64");
+    const forwardArgs = { ...args, content: base64Content };
+    delete forwardArgs.file_path;
+    console.error(
+      `[cortex-mcp] ${toolName}: reading local file (${(fileSize / 1024).toFixed(1)}KB), forwarding as base64`
+    );
+    const response = await cortex.callTool(toolName, forwardArgs);
+    if (response.error) {
+      return {
+        content: [{ type: "text", text: response.error.message }],
+        isError: true
+      };
+    }
+    return response.result;
+  }
+  console.error(
+    `[cortex-mcp] ${toolName}: large file (${(fileSize / 1024 / 1024).toFixed(1)}MB), using upload session`
+  );
+  const prefix = toolName.includes("__") ? toolName.split("__")[0] + "__" : "";
+  const sessionResponse = await cortex.callTool(`${prefix}create_upload_session`, {
+    path: args.path
+  });
+  if (sessionResponse.error) {
+    return {
+      content: [{ type: "text", text: sessionResponse.error.message }],
+      isError: true
+    };
+  }
+  const sessionResult = sessionResponse.result;
+  let sessionData;
+  try {
+    sessionData = JSON.parse(sessionResult.content[0].text);
+  } catch {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        success: false,
+        error: "Failed to parse upload session response from backend"
+      }) }],
+      isError: true
+    };
+  }
+  const uploadUrl = sessionData.uploadUrl;
+  if (!uploadUrl) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        success: false,
+        error: "Backend did not return an uploadUrl"
+      }) }],
+      isError: true
+    };
+  }
+  const fileBuffer = readFileSync4(filePath);
+  const chunkSize = 10 * 1024 * 1024;
+  const total = fileBuffer.length;
+  let lastResponse = null;
+  for (let start = 0; start < total; start += chunkSize) {
+    const end = Math.min(start + chunkSize, total);
+    const chunk = fileBuffer.subarray(start, end);
+    console.error(
+      `[cortex-mcp] Uploading chunk ${start}-${end - 1}/${total}`
+    );
+    lastResponse = await fetch(uploadUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Length": String(chunk.length),
+        "Content-Range": `bytes ${start}-${end - 1}/${total}`
+      },
+      body: chunk,
+      signal: AbortSignal.timeout(12e4)
+      // 2 min per chunk
+    });
+    if (!lastResponse.ok && lastResponse.status !== 202) {
+      const errText = await lastResponse.text();
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          success: false,
+          error: `Upload chunk failed (${lastResponse.status}): ${errText.slice(0, 200)}`
+        }) }],
+        isError: true
+      };
+    }
+  }
+  let driveItem = {};
+  if (lastResponse) {
+    try {
+      driveItem = await lastResponse.json();
+    } catch {
+    }
+  }
+  return {
+    content: [{ type: "text", text: JSON.stringify({
+      success: true,
+      file: driveItem,
+      message: `Uploaded '${args.path}' (${(fileSize / 1024).toFixed(1)}KB) via upload session`
+    }) }],
+    isError: false
+  };
+}
 async function startStdioServer(options) {
   const { serverUrl, apiKey, endpoint = "cortex" } = options;
   const cortex = new CortexHttpClient(serverUrl, apiKey, endpoint);
@@ -1101,12 +1289,18 @@ async function startStdioServer(options) {
       throw new Error(response.error.message);
     }
     const result = response.result;
-    return { tools: result.tools || [] };
+    const tools = (result.tools || []).map(overrideUploadToolSchema);
+    return { tools };
   });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     await ensureInitialized();
     const { name, arguments: args } = request.params;
-    const response = await cortex.callTool(name, args ?? {});
+    const typedArgs = args ?? {};
+    const baseName = name.includes("__") ? name.split("__").pop() : name;
+    if (UPLOAD_TOOLS.has(baseName) && typedArgs.file_path) {
+      return handleLocalFileUpload(cortex, name, typedArgs);
+    }
+    const response = await cortex.callTool(name, typedArgs);
     if (response.error) {
       return {
         content: [{ type: "text", text: response.error.message }],