@sisense/mcp-server 0.2.1

package/dist/widget-renderer-66ws3xtk.js

@@ -0,0 +1,312 @@
+import {
+  require_dist_cjs as require_dist_cjs2,
+  sanitizeError,
+  toKebabCase
+} from "./sse-server-36t17nga.js";
+import {
+  require_dist_cjs
+} from "./index-p1pxtmwn.js";
+import"./index-er0yspcy.js";
+import {
+  Fs
+} from "./sse-server-brx9qtyd.js";
+import"./sse-server-3e0efmg2.js";
+import"./sse-server-4b60tg0c.js";
+import"./sse-server-4jjec4fz.js";
+import"./sse-server-nwjjjz6x.js";
+import"./sse-server-qj4zxq0f.js";
+import"./sse-server-txz5g5t0.js";
+import"./sse-server-epd916s3.js";
+import"./sse-server-5tmgacdx.js";
+import"./sse-server-4g9za0qq.js";
+import"./index-g8bgq79c.js";
+import"./sse-server-mkesh468.js";
+import"./sse-server-3343e7xh.js";
+import {
+  __toESM
+} from "./sse-server-7wcvyxyj.js";
+
+// src/utils/widget-renderer/widget-renderer.ts
+var import_client_s3 = __toESM(require_dist_cjs2(), 1);
+var import_credential_provider_web_identity = __toESM(require_dist_cjs(), 1);
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+
+// src/utils/widget-renderer/widget-ct-runner.ts
+import { spawn } from "node:child_process";
+import { writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { randomBytes } from "node:crypto";
+import { fileURLToPath } from "node:url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+function getProjectRoot() {
+  const cwd = process.cwd();
+  if (existsSync(join(cwd, "playwright-ct.config.ts"))) {
+    return cwd;
+  }
+  const relativePath = join(__dirname2, "..", "..", "..");
+  if (existsSync(join(relativePath, "playwright-ct.config.ts"))) {
+    return relativePath;
+  }
+  return cwd;
+}
+var PROJECT_ROOT = getProjectRoot();
+async function renderChartWidgetWithPlaywrightCT(config) {
+  const startTime = Date.now();
+  const width = config.width || 1000;
+  const height = config.height || 600;
+  let screenshotPath = "";
+  try {
+    const testId = randomBytes(8).toString("hex");
+    const testDir = join(tmpdir(), `widget-ct-${testId}`);
+    mkdirSync(testDir, { recursive: true });
+    const configPath = join(testDir, "widget-config.json");
+    const configData = {
+      widgetProps: config.widgetProps,
+      sisenseContextProviderProps: config.sisenseContextProviderProps,
+      width,
+      height,
+      outputName: config.outputName
+    };
+    const serializedConfig = Fs.stringify(configData);
+    writeFileSync(configPath, serializedConfig, "utf8");
+    const screenshotsDir = join(PROJECT_ROOT, "__screenshots__");
+    mkdirSync(screenshotsDir, { recursive: true });
+    const chartTitleKebab = toKebabCase(config.outputName || "untitled-widget");
+    const timestamp = Date.now().toString();
+    const customFilename = `widget-${chartTitleKebab}-${timestamp}.png`;
+    screenshotPath = join(screenshotsDir, customFilename);
+    const testFilePath = join(PROJECT_ROOT, "src/utils/widget-renderer/widget-renderer.spec.tsx");
+    return await new Promise((resolve) => {
+      const renderStart = Date.now();
+      console.info("Starting Playwright CT", {
+        cwd: PROJECT_ROOT,
+        testFile: testFilePath,
+        configPath,
+        screenshotPath,
+        chromiumPath: process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH
+      });
+      const playwrightProcess = spawn("node", [
+        "./node_modules/.bin/playwright",
+        "test",
+        "--config=playwright-ct.config.ts",
+        testFilePath,
+        "--reporter=list"
+      ], {
+        cwd: PROJECT_ROOT,
+        env: {
+          ...process.env,
+          WIDGET_CONFIG_PATH: configPath,
+          SCREENSHOT_OUTPUT_PATH: screenshotPath
+        },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      console.info("Playwright process spawned", { pid: playwrightProcess.pid });
+      let stdout = "";
+      let stderr = "";
+      playwrightProcess.stdout?.on("data", (data) => {
+        const chunk = data.toString();
+        stdout += chunk;
+        console.info("Playwright stdout:", chunk.trim());
+      });
+      playwrightProcess.stderr?.on("data", (data) => {
+        const chunk = data.toString();
+        stderr += chunk;
+        console.info("Playwright stderr:", chunk.trim());
+      });
+      const killTimeout = setTimeout(() => {
+        console.error("Playwright process timed out after 120s, killing...");
+        playwrightProcess.kill("SIGKILL");
+      }, 120000);
+      playwrightProcess.on("error", (err) => {
+        clearTimeout(killTimeout);
+        const totalMs = Date.now() - startTime;
+        resolve({
+          pngPath: screenshotPath,
+          success: false,
+          error: `Failed to spawn Playwright process: ${err.message}`,
+          timings: {
+            renderMs: 0,
+            totalMs
+          }
+        });
+      });
+      playwrightProcess.on("close", (code) => {
+        clearTimeout(killTimeout);
+        console.info("Playwright process exited", {
+          code,
+          stdoutLength: stdout.length,
+          stderrLength: stderr.length
+        });
+        const renderMs = Date.now() - renderStart;
+        const totalMs = Date.now() - startTime;
+        if (code === 0) {
+          resolve({
+            pngPath: screenshotPath,
+            success: true,
+            timings: {
+              renderMs,
+              totalMs
+            }
+          });
+        } else {
+          resolve({
+            pngPath: screenshotPath,
+            success: false,
+            error: stderr || stdout,
+            timings: {
+              renderMs,
+              totalMs
+            }
+          });
+        }
+      });
+    });
+  } catch (err) {
+    const totalMs = Date.now() - startTime;
+    return {
+      pngPath: screenshotPath,
+      success: false,
+      error: `Failed to create chart: ${err instanceof Error ? err.message : String(err)}`,
+      timings: {
+        renderMs: 0,
+        totalMs
+      }
+    };
+  }
+}
+
+// src/utils/widget-renderer/widget-renderer.ts
+var s3Client;
+function getS3Client() {
+  if (s3Client !== undefined) {
+    return s3Client;
+  }
+  if (!process.env.SCREENSHOTS_BUCKET) {
+    s3Client = null;
+    return null;
+  }
+  const region = process.env.AWS_REGION || "us-east-1";
+  if (process.env.AWS_WEB_IDENTITY_TOKEN_FILE) {
+    s3Client = new import_client_s3.S3Client({
+      region,
+      credentials: import_credential_provider_web_identity.fromTokenFile()
+    });
+  } else {
+    s3Client = new import_client_s3.S3Client({ region });
+  }
+  return s3Client;
+}
+async function renderChartWidget(args) {
+  const {
+    widgetProps,
+    width = 800,
+    height = 500,
+    outputName,
+    maxRetries = 2,
+    sisenseUrl,
+    sisenseToken,
+    baseUrl
+  } = args;
+  const sisenseContextProviderProps = {
+    url: sisenseUrl,
+    token: sisenseToken,
+    showRuntimeErrors: true
+  };
+  console.info("Rendering chart from WidgetProps", {
+    chartType: widgetProps.chartType,
+    title: widgetProps.title,
+    width,
+    height
+  });
+  let lastError = null;
+  for (let attempt = 0;attempt <= maxRetries; attempt++) {
+    try {
+      if (attempt > 0) {
+        console.info(`Retry attempt ${attempt}/${maxRetries}`);
+      }
+      const result = await renderChartWidgetWithPlaywrightCT({
+        widgetProps,
+        sisenseContextProviderProps,
+        width,
+        height,
+        outputName: outputName || widgetProps.title || "widget"
+      });
+      if (!result.success) {
+        throw new Error(result.error || "Widget rendering failed");
+      }
+      console.info("Reading generated widget image", {
+        path: result.pngPath
+      });
+      if (!result.pngPath) {
+        throw new Error("Widget rendering succeeded but no output path was returned");
+      }
+      const imageBuffer = readFileSync(result.pngPath);
+      const filename = basename(result.pngPath);
+      if (!filename) {
+        throw new Error(`Invalid screenshot path: ${result.pngPath}`);
+      }
+      const client = getS3Client();
+      if (client && process.env.SCREENSHOTS_BUCKET) {
+        const bucket = process.env.SCREENSHOTS_BUCKET;
+        try {
+          await client.send(new import_client_s3.PutObjectCommand({
+            Bucket: bucket,
+            Key: filename,
+            Body: imageBuffer,
+            ContentType: "image/png"
+          }));
+          console.info("Screenshot uploaded to S3", { bucket, filename });
+        } catch (s3Error) {
+          const sanitized2 = sanitizeError(s3Error);
+          console.error("Failed to upload screenshot to S3", {
+            bucket,
+            filename,
+            error: sanitized2.message
+          });
+          throw new Error(`S3 upload failed: ${sanitized2.message}`);
+        }
+      }
+      const publicUrl = `${baseUrl.replace(/\/$/, "")}/screenshots/${filename}`;
+      console.info("Widget rendered successfully", {
+        outputPath: result.pngPath,
+        imageSize: imageBuffer.length,
+        publicUrl,
+        timings: result.timings
+      });
+      const toolResult = {
+        content: [
+          {
+            type: "text",
+            text: publicUrl
+          }
+        ]
+      };
+      console.info(">>> CHART TOOL RESULT", {
+        contentCount: toolResult.content.length,
+        publicUrl
+      });
+      return toolResult;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < maxRetries) {
+        const sanitized2 = sanitizeError(lastError);
+        console.warn(`Render attempt ${attempt + 1} failed, retrying...`, {
+          error: sanitized2.message
+        });
+        await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
+      }
+    }
+  }
+  const sanitized = sanitizeError(lastError, false);
+  console.error("Failed to render widget after retries", {
+    attempts: maxRetries + 1,
+    error: sanitized.message
+  });
+  throw new Error(sanitized.message || "Widget rendering failed");
+}
+export {
+  renderChartWidget
+};

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@sisense/mcp-server",
+  "version": "0.2.1",
+  "mcpName": "io.github.sisense/mcp-server",
+  "homepage": "https://github.com/sisense/sisense-mcp-server#readme",
+  "description": "MCP server leveraging Sisense Intelligence for actionable insights and analytics.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sisense/sisense-mcp-server.git"
+  },
+  "keywords": [
+    "Sisense",
+    "Sisense Intelligence",
+    "MCP Server",
+    "Analytics"
+  ],
+  "author": "Sisense",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "type": "module",
+  "main": "dist/sse-server.js",
+  "bin": {
+    "sisense-mcp-server": "dist/sse-server.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "cross-env INPUT=view.html vite build && bun build src/sse-server.ts --outdir dist --target node --format esm --splitting",
+    "build:view": "cross-env INPUT=view.html vite build",
+    "dev": "bun run --watch src/sse-server.ts",
+    "start": "bun run dist/sse-server.js",
+    "test": "bun test",
+    "test:e2e": "bun test e2e",
+    "lint": "eslint src/**/*.ts",
+    "type-check": "tsc --noEmit",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\" \"e2e/**/*.{ts,tsx}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,tsx}\" \"e2e/**/*.{ts,tsx}\"",
+    "postinstall": "playwright install chromium"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.756.0",
+    "@aws-sdk/s3-request-presigner": "^3.756.0",
+    "@modelcontextprotocol/ext-apps": "1.0.1",
+    "@modelcontextprotocol/sdk": "1.26.0",
+    "@playwright/experimental-ct-react": "^1.56.1",
+    "@playwright/test": "^1.56.1",
+    "@sisense/sdk-ai-core": "0.5.1",
+    "@sisense/sdk-data": "2.20.0",
+    "@sisense/sdk-ui": "2.20.0",
+    "playwright": "^1.56.1",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.0.0",
+    "@types/node": "^20.10.0",
+    "@vitejs/plugin-react": "^4.3.4",
+    "cross-env": "^7.0.3",
+    "@types/react": "^18.3.1",
+    "@types/react-dom": "^18.3.1",
+    "@typescript-eslint/eslint-plugin": "^6.13.0",
+    "@typescript-eslint/parser": "^6.13.0",
+    "eslint": "^8.54.0",
+    "prettier": "^3.0.0",
+    "typescript": "^5.3.3",
+    "vite": "^6.0.0",
+    "vite-plugin-singlefile": "^2.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "bun": ">=1.0.0"
+  },
+  "bugs": {
+    "url": "https://github.com/sisense/sisense-mcp-server/issues"
+  }
+}