@trops/dash-core 0.1.77 → 0.1.79

package/dist/mcp/mcpServerCatalog.json

@@ -200,19 +200,22 @@
       "tags": ["google", "files", "cloud-storage"],
       "mcpConfig": {
         "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "-p", "@modelcontextprotocol/server-gdrive", "node", "{{MCP_DIR}}/gdrive-server.mjs"],
+        "command": "node",
+        "args": ["{{MCP_DIR}}/servers/google-drive.js"],
         "envMapping": {
           "GDRIVE_OAUTH_PATH": "oauthKeysPath"
         },
         "staticEnv": {
-          "GDRIVE_CREDENTIALS_PATH": "~/.gdrive-mcp/credentials.json",
-          "GDRIVE_OAUTH_KEYS_PATH": "~/.gdrive-mcp/gcp-oauth.keys.json"
+          "GDRIVE_CREDENTIALS_PATH": "~/.gdrive-mcp/credentials.json"
+        },
+        "tokenRefresh": {
+          "credentialsPath": "~/.gdrive-mcp/credentials.json",
+          "oauthKeysPath": "~/.gdrive-mcp/gcp-oauth.keys.json"
         }
       },
       "authCommand": {
-        "command": "npx",
-        "args": ["-y", "@modelcontextprotocol/server-gdrive", "auth"],
+        "command": "node",
+        "args": ["{{MCP_DIR}}/servers/google-drive.js", "auth"],
         "setup": {
           "copyCredential": {
             "from": "oauthKeysPath",
@@ -243,7 +246,11 @@
       "mcpConfig": {
         "transport": "stdio",
         "command": "npx",
-        "args": ["-y", "@gongrzhe/server-gmail-autoauth-mcp"]
+        "args": ["-y", "@gongrzhe/server-gmail-autoauth-mcp"],
+        "tokenRefresh": {
+          "credentialsPath": "~/.gmail-mcp/credentials.json",
+          "oauthKeysPath": "~/.gmail-mcp/gcp-oauth.keys.json"
+        }
       },
       "authCommand": {
         "command": "npx",

package/dist/mcp/servers/servers/google-drive.js

@@ -0,0 +1,355 @@
+#!/usr/bin/env node
+/**
+ * Custom Google Drive MCP server.
+ *
+ * Replaces the archived @modelcontextprotocol/server-gdrive which has a
+ * fundamental bug: it creates OAuth2 clients without client_id/client_secret,
+ * so it can never refresh tokens.
+ *
+ * Exposes a single "search" tool with { query: string } input — identical
+ * interface to the original, so no widget changes are needed.
+ *
+ * Usage:
+ *   MCP server:  node google-drive.js          (stdio transport)
+ *   OAuth auth:  node google-drive.js auth      (browser-based OAuth flow)
+ *
+ * Environment variables:
+ *   GDRIVE_CREDENTIALS_PATH — path to stored OAuth credentials (access/refresh tokens)
+ *   GDRIVE_OAUTH_PATH       — path to Google OAuth client keys file
+ */
+const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
+const {
+  StdioServerTransport,
+} = require("@modelcontextprotocol/sdk/server/stdio.js");
+const fs = require("fs");
+const https = require("https");
+const path = require("path");
+
+const credentialsPath = (process.env.GDRIVE_CREDENTIALS_PATH || "").replace(
+  /^~/,
+  process.env.HOME || "",
+);
+const oauthKeysPath = (process.env.GDRIVE_OAUTH_PATH || "").replace(
+  /^~/,
+  process.env.HOME || "",
+);
+
+/**
+ * Read OAuth client credentials from the keys file.
+ */
+function getClientCredentials() {
+  const keysFile = JSON.parse(fs.readFileSync(oauthKeysPath, "utf8"));
+  const keyData = keysFile.installed || keysFile.web;
+  return {
+    client_id: keyData.client_id,
+    client_secret: keyData.client_secret,
+  };
+}
+
+/**
+ * Read stored credentials (access_token, refresh_token, expiry_date).
+ */
+function readCredentials() {
+  return JSON.parse(fs.readFileSync(credentialsPath, "utf8"));
+}
+
+/**
+ * Get a valid access token, refreshing if expired.
+ */
+async function getAccessToken() {
+  let creds = readCredentials();
+  const { client_id, client_secret } = getClientCredentials();
+
+  // Still valid (>60s remaining)?
+  if (creds.expiry_date && creds.expiry_date > Date.now() + 60 * 1000) {
+    return creds.access_token;
+  }
+
+  // Refresh
+  const postData = [
+    `client_id=${encodeURIComponent(client_id)}`,
+    `client_secret=${encodeURIComponent(client_secret)}`,
+    `refresh_token=${encodeURIComponent(creds.refresh_token)}`,
+    "grant_type=refresh_token",
+  ].join("&");
+
+  const body = await new Promise((resolve, reject) => {
+    const req = https.request(
+      {
+        hostname: "oauth2.googleapis.com",
+        path: "/token",
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Content-Length": Buffer.byteLength(postData),
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            resolve(JSON.parse(data));
+          } else {
+            reject(
+              new Error(`Token refresh failed (${res.statusCode}): ${data}`),
+            );
+          }
+        });
+      },
+    );
+    req.on("error", reject);
+    req.write(postData);
+    req.end();
+  });
+
+  creds.access_token = body.access_token;
+  creds.expiry_date = Date.now() + (body.expires_in || 3600) * 1000;
+  if (body.refresh_token) {
+    creds.refresh_token = body.refresh_token;
+  }
+  fs.writeFileSync(credentialsPath, JSON.stringify(creds, null, 2));
+  return creds.access_token;
+}
+
+/**
+ * Make a Google Drive API request.
+ */
+function driveRequest(path, token) {
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      {
+        hostname: "www.googleapis.com",
+        path,
+        method: "GET",
+        headers: { Authorization: `Bearer ${token}` },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            resolve(JSON.parse(data));
+          } else {
+            reject(new Error(`Drive API error (${res.statusCode}): ${data}`));
+          }
+        });
+      },
+    );
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+// ── Auth subcommand ──────────────────────────────────────────────────
+if (process.argv[2] === "auth") {
+  (async () => {
+    try {
+      const http = require("http");
+      const { URL } = require("url");
+      const { client_id, client_secret } = getClientCredentials();
+
+      const keysFile = JSON.parse(fs.readFileSync(oauthKeysPath, "utf8"));
+      const keyData = keysFile.installed || keysFile.web;
+      const redirectUri =
+        keyData.redirect_uris?.[0] || "http://localhost:3000/oauth2callback";
+
+      // Extract port from redirect URI
+      const redirectUrl = new URL(redirectUri);
+      const port = parseInt(redirectUrl.port, 10) || 3000;
+
+      const scopes = ["https://www.googleapis.com/auth/drive.readonly"];
+
+      const authUrl =
+        `https://accounts.google.com/o/oauth2/v2/auth?` +
+        `client_id=${encodeURIComponent(client_id)}` +
+        `&redirect_uri=${encodeURIComponent(redirectUri)}` +
+        `&response_type=code` +
+        `&scope=${encodeURIComponent(scopes.join(" "))}` +
+        `&access_type=offline` +
+        `&prompt=consent`;
+
+      console.log(
+        `\nOpen this URL in your browser to authorize:\n\n${authUrl}\n`,
+      );
+
+      // Start local server to catch the callback
+      const server = http.createServer(async (req, res) => {
+        const reqUrl = new URL(req.url, `http://localhost:${port}`);
+        const code = reqUrl.searchParams.get("code");
+        if (!code) {
+          res.writeHead(400);
+          res.end("Missing authorization code");
+          return;
+        }
+
+        // Exchange code for tokens
+        const postData = [
+          `code=${encodeURIComponent(code)}`,
+          `client_id=${encodeURIComponent(client_id)}`,
+          `client_secret=${encodeURIComponent(client_secret)}`,
+          `redirect_uri=${encodeURIComponent(redirectUri)}`,
+          `grant_type=authorization_code`,
+        ].join("&");
+
+        try {
+          const body = await new Promise((resolve, reject) => {
+            const tokenReq = https.request(
+              {
+                hostname: "oauth2.googleapis.com",
+                path: "/token",
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/x-www-form-urlencoded",
+                  "Content-Length": Buffer.byteLength(postData),
+                },
+              },
+              (tokenRes) => {
+                let data = "";
+                tokenRes.on("data", (chunk) => (data += chunk));
+                tokenRes.on("end", () => {
+                  if (tokenRes.statusCode === 200) {
+                    resolve(JSON.parse(data));
+                  } else {
+                    reject(
+                      new Error(
+                        `Token exchange failed (${tokenRes.statusCode}): ${data}`,
+                      ),
+                    );
+                  }
+                });
+              },
+            );
+            tokenReq.on("error", reject);
+            tokenReq.write(postData);
+            tokenReq.end();
+          });
+
+          const creds = {
+            access_token: body.access_token,
+            refresh_token: body.refresh_token,
+            expiry_date: Date.now() + (body.expires_in || 3600) * 1000,
+          };
+
+          const credDir = path.dirname(credentialsPath);
+          fs.mkdirSync(credDir, { recursive: true });
+          fs.writeFileSync(credentialsPath, JSON.stringify(creds, null, 2));
+
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(
+            "<h1>Authorization successful!</h1><p>You can close this tab.</p>",
+          );
+          console.log(`\nCredentials saved to ${credentialsPath}\n`);
+          server.close();
+          process.exit(0);
+        } catch (err) {
+          res.writeHead(500);
+          res.end(`Error: ${err.message}`);
+          console.error("Token exchange error:", err.message);
+          server.close();
+          process.exit(1);
+        }
+      });
+
+      server.listen(port, () => {
+        console.log(`Listening on port ${port} for OAuth callback...`);
+      });
+    } catch (err) {
+      console.error("Auth error:", err.message);
+      process.exit(1);
+    }
+  })();
+} else {
+  // ── MCP Server ──────────────────────────────────────────────────────
+  (async () => {
+    const server = new Server(
+      { name: "google-drive", version: "1.0.0" },
+      { capabilities: { tools: {} } },
+    );
+
+    server.setRequestHandler({ method: "tools/list" }, async () => ({
+      tools: [
+        {
+          name: "search",
+          description: "Search for files in Google Drive by name or content",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "Search query",
+              },
+            },
+            required: ["query"],
+          },
+        },
+      ],
+    }));
+
+    server.setRequestHandler({ method: "tools/call" }, async (request) => {
+      if (request.params.name !== "search") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Unknown tool: ${request.params.name}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const query = request.params.arguments?.query;
+      if (!query) {
+        return {
+          content: [{ type: "text", text: "Missing required argument: query" }],
+          isError: true,
+        };
+      }
+
+      try {
+        const token = await getAccessToken();
+        const encodedQuery = encodeURIComponent(
+          `fullText contains '${query.replace(/'/g, "\\'")}'`,
+        );
+        const result = await driveRequest(
+          `/drive/v3/files?q=${encodedQuery}&fields=files(id,name,mimeType,modifiedTime,webViewLink)&pageSize=20`,
+          token,
+        );
+
+        const files = result.files || [];
+        if (files.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No files found for query: ${query}`,
+              },
+            ],
+          };
+        }
+
+        const lines = files.map(
+          (f) =>
+            `${f.name} (${f.mimeType})${f.webViewLink ? ` - ${f.webViewLink}` : ""}`,
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Found ${files.length} files:\n${lines.join("\n")}`,
+            },
+          ],
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+          isError: true,
+        };
+      }
+    });
+
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  })();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@trops/dash-core",
-    "version": "0.1.77",
+    "version": "0.1.79",
     "description": "Core framework for Dash dashboard applications",
     "main": "dist/index.js",
     "module": "dist/index.esm.js",
@@ -19,9 +19,10 @@
     "scripts": {
         "build": "npm run build:renderer && npm run build:electron",
         "build:renderer": "rollup -c rollup.config.renderer.mjs",
-        "build:electron": "rollup -c rollup.config.electron.mjs && mkdir -p dist/mcp && cp electron/mcp/mcpServerCatalog.json electron/mcp/gdrive-server.mjs dist/mcp/",
+        "build:electron": "rollup -c rollup.config.electron.mjs && mkdir -p dist/mcp/servers && cp electron/mcp/mcpServerCatalog.json dist/mcp/ && cp -r electron/mcp/servers/ dist/mcp/servers/",
         "clean": "rm -rf dist",
         "prepublishOnly": "npm run clean && npm run build",
+        "test:mcp": "node --test electron/controller/mcpController.test.js electron/mcp/mcpServerCatalog.test.js",
         "prettify": "prettier --write \"src/**/*.{js,jsx,ts,tsx}\" \"electron/**/*.js\""
     },
     "peerDependencies": {

package/dist/mcp/gdrive-server.mjs

@@ -1,220 +0,0 @@
-#!/usr/bin/env node
-/**
- * gdrive-server.mjs
- *
- * Local Google Drive MCP server wrapper that fixes the upstream OAuth2 bug.
- *
- * The upstream @modelcontextprotocol/server-gdrive creates OAuth2 without
- * client_id/client_secret, which prevents token refresh after ~1 hour.
- * This wrapper reads both the credentials file AND the OAuth keys file
- * to properly initialize OAuth2 with client credentials.
- *
- * Env vars:
- *   GDRIVE_CREDENTIALS_PATH  - path to saved credentials (access_token, refresh_token)
- *   GDRIVE_OAUTH_KEYS_PATH   - path to gcp-oauth.keys.json (client_id, client_secret)
- */
-
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-    CallToolRequestSchema,
-    ListResourcesRequestSchema,
-    ListToolsRequestSchema,
-    ReadResourceRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import fs from "fs";
-import { google } from "googleapis";
-
-const drive = google.drive("v3");
-
-const server = new Server(
-    {
-        name: "dash/gdrive",
-        version: "1.0.0",
-    },
-    {
-        capabilities: {
-            resources: {},
-            tools: {},
-        },
-    }
-);
-
-// --- List Resources ---
-server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
-    const pageSize = 10;
-    const params = {
-        pageSize,
-        fields: "nextPageToken, files(id, name, mimeType)",
-    };
-    if (request.params?.cursor) {
-        params.pageToken = request.params.cursor;
-    }
-    const res = await drive.files.list(params);
-    const files = res.data.files;
-    return {
-        resources: files.map((file) => ({
-            uri: `gdrive:///${file.id}`,
-            mimeType: file.mimeType,
-            name: file.name,
-        })),
-        nextCursor: res.data.nextPageToken,
-    };
-});
-
-// --- Read Resource ---
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const fileId = request.params.uri.replace("gdrive:///", "");
-    const file = await drive.files.get({
-        fileId,
-        fields: "mimeType",
-    });
-
-    // Google Docs/Sheets/etc need export
-    if (file.data.mimeType?.startsWith("application/vnd.google-apps")) {
-        let exportMimeType;
-        switch (file.data.mimeType) {
-            case "application/vnd.google-apps.document":
-                exportMimeType = "text/markdown";
-                break;
-            case "application/vnd.google-apps.spreadsheet":
-                exportMimeType = "text/csv";
-                break;
-            case "application/vnd.google-apps.presentation":
-                exportMimeType = "text/plain";
-                break;
-            case "application/vnd.google-apps.drawing":
-                exportMimeType = "image/png";
-                break;
-            default:
-                exportMimeType = "text/plain";
-        }
-        const res = await drive.files.export(
-            { fileId, mimeType: exportMimeType },
-            { responseType: "text" }
-        );
-        return {
-            contents: [
-                {
-                    uri: request.params.uri,
-                    mimeType: exportMimeType,
-                    text: res.data,
-                },
-            ],
-        };
-    }
-
-    // Regular files — download content
-    const res = await drive.files.get(
-        { fileId, alt: "media" },
-        { responseType: "arraybuffer" }
-    );
-    const mimeType = file.data.mimeType || "application/octet-stream";
-    if (mimeType.startsWith("text/") || mimeType === "application/json") {
-        return {
-            contents: [
-                {
-                    uri: request.params.uri,
-                    mimeType,
-                    text: Buffer.from(res.data).toString("utf-8"),
-                },
-            ],
-        };
-    }
-    return {
-        contents: [
-            {
-                uri: request.params.uri,
-                mimeType,
-                blob: Buffer.from(res.data).toString("base64"),
-            },
-        ],
-    };
-});
-
-// --- List Tools ---
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            {
-                name: "search",
-                description: "Search for files in Google Drive",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        query: {
-                            type: "string",
-                            description: "Search query",
-                        },
-                    },
-                    required: ["query"],
-                },
-            },
-        ],
-    };
-});
-
-// --- Call Tool ---
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    if (request.params.name === "search") {
-        const userQuery = request.params.arguments?.query;
-        const escapedQuery = userQuery
-            .replace(/\\/g, "\\\\")
-            .replace(/'/g, "\\'");
-        const formattedQuery = `fullText contains '${escapedQuery}'`;
-        const res = await drive.files.list({
-            q: formattedQuery,
-            pageSize: 10,
-            fields: "files(id, name, mimeType, modifiedTime, size)",
-        });
-        const fileList = res.data.files
-            ?.map((file) => `${file.name} (${file.mimeType})`)
-            .join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Found ${res.data.files?.length ?? 0} files:\n${fileList}`,
-                },
-            ],
-            isError: false,
-        };
-    }
-    throw new Error("Tool not found");
-});
-
-// --- Load credentials and start server ---
-const credentialsPath = process.env.GDRIVE_CREDENTIALS_PATH;
-const oauthKeysPath = process.env.GDRIVE_OAUTH_KEYS_PATH;
-
-if (!credentialsPath || !fs.existsSync(credentialsPath)) {
-    console.error(
-        "Credentials not found. Please run OAuth auth flow first."
-    );
-    process.exit(1);
-}
-
-const credentials = JSON.parse(fs.readFileSync(credentialsPath, "utf-8"));
-
-// THE FIX: Read client_id and client_secret from the OAuth keys file
-// so that googleapis can refresh the access_token when it expires.
-let clientId, clientSecret;
-if (oauthKeysPath && fs.existsSync(oauthKeysPath)) {
-    const keysFile = JSON.parse(fs.readFileSync(oauthKeysPath, "utf-8"));
-    const keyData = keysFile.installed || keysFile.web;
-    if (keyData) {
-        clientId = keyData.client_id;
-        clientSecret = keyData.client_secret;
-    }
-}
-
-const auth = new google.auth.OAuth2(clientId, clientSecret);
-auth.setCredentials(credentials);
-google.options({ auth });
-
-console.error(
-    `Credentials loaded (refresh_token: ${credentials.refresh_token ? "present" : "missing"}). Starting server.`
-);
-
-const transport = new StdioServerTransport();
-await server.connect(transport);