toolbox-co-mcp-bridge 1.0.8 → 1.0.9

package/Dockerfile

@@ -0,0 +1,7 @@
+FROM node:20-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm install --only=production
+COPY . .
+EXPOSE 8080
+CMD ["npm", "start"]

package/index.js

@@ -1,86 +1,568 @@
-#!/usr/bin/env node
-import fetch from "node-fetch";
-import readline from "readline";
+import express from "express";
+import cors from "cors";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import crypto from "crypto";
+import bcrypt from "bcryptjs";
+import yaml from "yaml";
 
-const baseUrl = "https://toolbox-mcp-1058072229791.us-central1.run.app";
-const cid = crypto.randomBytes(8).toString('hex');
-const sseInitUrl = `${baseUrl}/sseInit?sessionId=${cid}&t=${Date.now()}`;
-const messageUrl = `${baseUrl}/message?sessionId=${cid}`;
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
 
-let isConnected = false;
-const messageQueue = [];
-let gcrCookie = '';
+const app = express();
+app.use(cors());
+
+// List of all 47 ToolBox Tools
+const ALL_TOOLS = [
+  { name: "format_json", desc: "Pretty prints and formats raw JSON string.", schema: { text: "string" } },
+  { name: "generate_uuid", desc: "Generates v4 UUIDs.", schema: {} },
+  { name: "encode_base64", desc: "Encodes plain text to Base64.", schema: { text: "string" } },
+  { name: "decode_base64", desc: "Decodes Base64 to plain text.", schema: { text: "string" } },
+  { name: "generate_password", desc: "Creates a secure password. Args: length (number), special (boolean).", schema: { length: "number", special: "boolean" } },
+  { name: "url_encode", desc: "URL encodes text.", schema: { text: "string" } },
+  { name: "url_decode", desc: "URL decodes text.", schema: { text: "string" } },
+  { name: "generate_hash", desc: "SHA256/MD5/SHA1 hash. Args: text, algo.", schema: { text: "string", algo: "string" } },
+  { name: "decode_jwt", desc: "Decodes JWT payload without verifying signature.", schema: { token: "string" } },
+  { name: "text_analyzer", desc: "Returns word/char count.", schema: { text: "string" } },
+  { name: "bcrypt_hash", desc: "Generates bcrypt hash from password.", schema: { text: "string", rounds: "number" } },
+  { name: "bcrypt_compare", desc: "Checks password against bcrypt hash. Args: text, hash.", schema: { text: "string", hash: "string" } },
+  { name: "color_hex_to_rgb", desc: "Converts HEX color to RGB formatting.", schema: { hex: "string" } },
+  { name: "html_encode", desc: "Converts characters to HTML entities.", schema: { text: "string" } },
+  { name: "html_decode", desc: "Converts HTML entities to characters.", schema: { text: "string" } },
+  { name: "yaml_to_json", desc: "Converts YAML to JSON string.", schema: { yamlText: "string" } },
+  { name: "json_to_yaml", desc: "Converts JSON to YAML string.", schema: { jsonText: "string" } },
+  { name: "utm_builder", desc: "Builds a complete UTM tracked URL. Args: url, source, medium, campaign.", schema: { url: "string", source: "string", medium: "string", campaign: "string" } },
+  { name: "social_media_limits", desc: "Checks platform constraints for social text.", schema: { text: "string" } },
+  { name: "json_to_csv", desc: "Converts flat JSON array string to CSV.", schema: { jsonArray: "string" } },
+  { name: "case_converter", desc: "Changes string case. Args: text, targetCase (upper, lower, camel, snake, kebab, title).", schema: { text: "string", targetCase: "string" } },
+  { name: "lorem_ipsum", desc: "Generates dummy text. Args: paragraphs (number).", schema: { paragraphs: "number" } },
+  { name: "duplicate_remover", desc: "Removes duplicate lines from text block.", schema: { text: "string" } },
+  { name: "freelance_rate_calc", desc: "Converts hourly rate to annual, or vice-versa. Args: rate, type (hourly|annual), hoursPerWeek.", schema: { rate: "number", type: "string", hoursPerWeek: "number" } },
+  { name: "tip_splitter", desc: "Calculates total and per-person cost. Args: bill, tipPercent, people.", schema: { bill: "number", tipPercent: "number", people: "number" } },
+  { name: "date_difference", desc: "Calculates days between two ISO dates. Args: start, end.", schema: { start: "string", end: "string" } },
+  { name: "percentage_calculator", desc: "Calculates what X percent of Y is, or what percent X is of Y. Args: x, y, mode (percentOf|isWhatPercentOf).", schema: { x: "number", y: "number", mode: "string" } },
+  { name: "ig_spacer", desc: "Replaces standard linebreaks with instagram-friendly zero-width joiners.", schema: { text: "string" } },
+  { name: "hashtag_mixer", desc: "Randomly shuffles a list of hashtags.", schema: { tags: "string" } },
+  { name: "regex_tester", desc: "Tests text against regex. Args: pattern, flags, testString.", schema: { pattern: "string", flags: "string", testString: "string" } },
+  { name: "loan_amortization_simulator", desc: "Simulates monthly payments and interest schedules for a loan. Args: principal (number), rate (number), termYears (number).", schema: { principal: "number", rate: "number", termYears: "number" } },
+  { name: "options_pricing_black_scholes", desc: "Calculates European option prices using Black-Scholes. Args: underlyingPrice (number), strikePrice (number), yearsToExpiry (number), volatility (number), riskFreeRate (number).", schema: { underlyingPrice: "number", strikePrice: "number", yearsToExpiry: "number", volatility: "number", riskFreeRate: "number" } },
+  { name: "cap_table_dilution", desc: "Calculates post-round ownership and shares. Args: preMoneyValuation (number), investmentAmount (number), founderShares (number).", schema: { preMoneyValuation: "number", investmentAmount: "number", founderShares: "number" } },
+  { name: "nda_clause_auditor", desc: "Audits NDAs for restrictive or missing clauses. Args: text (string).", schema: { text: "string" } },
+  { name: "gdpr_privacy_auditor", desc: "Checks privacy policy text for basic GDPR compliance. Args: text (string).", schema: { text: "string" } },
+  { name: "trademark_snippet_compiler", desc: "Compiles a standardized license header block. Args: licenseType (string), holderName (string), year (string).", schema: { licenseType: "string", holderName: "string", year: "string" } },
+  { name: "csv_to_sql_ddl", desc: "Generates SQL CREATE TABLE and INSERT statements from raw CSV. Args: csvText (string), tableName (string).", schema: { csvText: "string", tableName: "string" } },
+  { name: "json_schema_to_openapi", desc: "Generates an OpenAPI spec block from JSON. Args: jsonText (string).", schema: { jsonText: "string" } },
+  { name: "statistical_hypothesis_solver", desc: "Calculates t-statistic and p-value for two sample means. Args: mean1 (number), mean2 (number), sd1 (number), sd2 (number), n1 (number), n2 (number).", schema: { mean1: "number", mean2: "number", sd1: "number", sd2: "number", n1: "number", n2: "number" } },
+  { name: "volumetric_shipping_estimator", desc: "Calculates volumetric weight and flags shipping over-billing. Args: length (number), width (number), height (number), weight (number), divisor (number).", schema: { length: "number", width: "number", height: "number", weight: "number", divisor: "number" } },
+  { name: "product_profit_margin", desc: "Calculates product margins and return on ad spend. Args: costOfGoods (number), retailPrice (number), marketingSpend (number), unitsSold (number).", schema: { costOfGoods: "number", retailPrice: "number", marketingSpend: "number", unitsSold: "number" } },
+  { name: "ecom_listing_seo_auditor", desc: "Audits e-commerce listings for titles, description lengths, and SEO. Args: title (string), description (string).", schema: { title: "string", description: "string" } },
+  { name: "rental_yield_calculator", desc: "Calculates rental yield and cap rates for a real estate asset. Args: purchasePrice (number), monthlyRent (number), operatingExpenses (number).", schema: { purchasePrice: "number", monthlyRent: "number", operatingExpenses: "number" } },
+  { name: "lease_cost_escalation", desc: "Generates a compound rent escalation schedule over time. Args: baseRent (number), escalationRate (number), years (number).", schema: { baseRent: "number", escalationRate: "number", years: "number" } },
+  { name: "tabular_synthetic_generator", desc: "Generates synthetic CSV rows for healthcare, finance, or clickstream. Args: domain (string), sampleSize (number).", schema: { domain: "string", sampleSize: "number" } },
+  { name: "academic_anonymizer", desc: "Anonymizes CSV text client-side via SHA-256 tokens and binning. Args: csvText (string), salt (string).", schema: { csvText: "string", salt: "string" } },
+  { name: "hybrid_dataset_fuser", desc: "Fuses and scales up CSV baseline datasets while preserving statistics. Args: csvText (string), multiplier (number).", schema: { csvText: "string", multiplier: "number" } },
+];
+
+function createServer() {
+  const mcpServer = new Server({ name: "toolbox-co-remote", version: "1.0.0" }, { capabilities: { tools: {} } });
+
+  mcpServer.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: ALL_TOOLS.map(t => {
+        const props = {};
+        const required = Object.keys(t.schema);
+        for (const [key, type] of Object.entries(t.schema)) {
+          props[key] = { type };
+        }
+        return {
+          name: t.name,
+          description: t.desc,
+          inputSchema: { type: "object", properties: props, required }
+        };
+      })
+    };
+  });
+
+  mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    let res = "";
 
-async function sendPost(msg) {
     try {
-        const headers = { 'Content-Type': 'application/json' };
-        if (gcrCookie) { headers['Cookie'] = gcrCookie; }
-        
-        const response = await fetch(messageUrl, {
-            method: 'POST',
-            headers,
-            body: msg
-        });
-        if (!response.ok) {
-            console.error(`HTTP Error from ToolBox server: ${response.status} ${response.statusText}`);
-            console.error(`Server response body: ${await response.text()}`);
+      switch (name) {
+        case "format_json": res = JSON.stringify(JSON.parse(args.text), null, 2); break;
+        case "generate_uuid": res = crypto.randomUUID(); break;
+        case "encode_base64": res = Buffer.from(args.text).toString("base64"); break;
+        case "decode_base64": res = Buffer.from(args.text, "base64").toString("utf-8"); break;
+        case "generate_password":
+           const len = args.length || 16;
+           const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" + (args.special !== false ? "!@#$%^&*()_+-=" : "");
+           for (let i = 0; i < len; i++) res += chars[Math.floor(Math.random() * chars.length)];
+           break;
+        case "url_encode": res = encodeURIComponent(args.text); break;
+        case "url_decode": res = decodeURIComponent(args.text); break;
+        case "generate_hash": res = crypto.createHash(args.algo || "sha256").update(args.text).digest("hex"); break;
+        case "decode_jwt":
+           const parts = args.token.split(".");
+           if (parts.length !== 3) throw new Error("Invalid JWT");
+           res = JSON.stringify({
+             header: JSON.parse(Buffer.from(parts[0], "base64url").toString()),
+             payload: JSON.parse(Buffer.from(parts[1], "base64url").toString())
+           }, null, 2); break;
+        case "text_analyzer":
+           res = JSON.stringify({
+             chars: args.text.length,
+             words: args.text.split(/\s+/).filter(w => w.length).length,
+             lines: args.text.split('\n').length
+           }, null, 2); break;
+        case "bcrypt_hash": res = bcrypt.hashSync(args.text, args.rounds || 10); break;
+        case "bcrypt_compare": res = bcrypt.compareSync(args.text, args.hash) ? "Match!" : "Does not match."; break;
+        case "color_hex_to_rgb":
+           let hex = args.hex.replace(/^#/, '');
+           if (hex.length === 3) hex = hex.split('').map(x => x+x).join('');
+           const r = parseInt(hex.substring(0, 2), 16), g = parseInt(hex.substring(2, 4), 16), b = parseInt(hex.substring(4, 6), 16);
+           if (isNaN(r) || isNaN(g) || isNaN(b)) throw new Error("Invalid hex");
+           res = `rgb(${r}, ${g}, ${b})`; break;
+        case "html_encode": res = args.text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;"); break;
+        case "html_decode": res = args.text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&"); break;
+        case "yaml_to_json": res = JSON.stringify(yaml.parse(args.yamlText), null, 2); break;
+        case "json_to_yaml": res = yaml.stringify(JSON.parse(args.jsonText)); break;
+        case "utm_builder":
+           const u = new URL(args.url.startsWith('http') ? args.url : `https://${args.url}`);
+           if (args.source) u.searchParams.set('utm_source', args.source);
+           if (args.medium) u.searchParams.set('utm_medium', args.medium);
+           if (args.campaign) u.searchParams.set('utm_campaign', args.campaign);
+           res = u.toString(); break;
+        case "social_media_limits":
+           const t = args.text;
+           res = JSON.stringify({ length: t.length, twitterOk: t.length <= 280, igOk: t.length <= 2200, linkedinOk: t.length <= 3000 }, null, 2); break;
+        case "json_to_csv":
+           const arr = JSON.parse(args.jsonArray);
+           if (!Array.isArray(arr) || !arr.length) throw new Error("Need JSON array of objects");
+           const keys = Object.keys(arr[0]);
+           res = [keys.join(","), ...arr.map(row => keys.map(k => `"${row[k]}"`).join(","))].join("\n"); break;
+        case "case_converter":
+           const txt = args.text;
+           switch (args.targetCase) {
+             case "upper": res = txt.toUpperCase(); break;
+             case "lower": res = txt.toLowerCase(); break;
+             case "camel": res = txt.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, (match, index) => { if (+match === 0) return ""; return index === 0 ? match.toLowerCase() : match.toUpperCase(); }); break;
+             case "snake": res = txt.replace(/\W+/g, " ").split(/ |\B(?=[A-Z])/).map(w => w.toLowerCase()).join('_'); break;
+             case "kebab": res = txt.replace(/\W+/g, " ").split(/ |\B(?=[A-Z])/).map(w => w.toLowerCase()).join('-'); break;
+             case "title": res = txt.replace(/\w\S*/g, (t) => t.charAt(0).toUpperCase() + t.substr(1).toLowerCase()); break;
+             default: throw new Error("Invalid case type");
+           } break;
+        case "lorem_ipsum":
+           const dummy = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.";
+           res = Array(args.paragraphs || 1).fill(dummy).join("\n\n"); break;
+        case "duplicate_remover":
+           const lines = args.text.split("\n");
+           res = [...new Set(lines)].join("\n"); break;
+        case "freelance_rate_calc":
+           const hpw = args.hoursPerWeek || 40;
+           if (args.type === "hourly") res = `Annual Rate: $${Math.round(args.rate * hpw * 52)}`;
+           else res = `Hourly Rate: $${(args.rate / (hpw * 52)).toFixed(2)}`; break;
+        case "tip_splitter":
+           const tipAmt = args.bill * (args.tipPercent / 100);
+           const tot = args.bill + tipAmt;
+           res = `Total: $${tot.toFixed(2)}, Per Person: $${(tot / args.people).toFixed(2)}`; break;
+        case "date_difference":
+           const d1 = new Date(args.start), d2 = new Date(args.end);
+           res = `${Math.abs(d2 - d1) / (1000 * 60 * 60 * 24)} days`; break;
+        case "percentage_calculator":
+           if (args.mode === "percentOf") res = `${(args.x / 100) * args.y}`;
+           else res = `${(args.x / args.y) * 100}%`; break;
+        case "ig_spacer": res = args.text.replace(/\n/g, "\n\u2063\n"); break;
+        case "hashtag_mixer":
+           let tags = args.tags.split(/[\s,]+/).filter(t => t.length);
+           res = tags.sort(() => 0.5 - Math.random()).join(" "); break;
+        case "regex_tester":
+           const re = new RegExp(args.pattern, args.flags || "");
+           const match = args.testString.match(re);
+           res = JSON.stringify({ success: !!match, matches: match }, null, 2); break;
+        case "loan_amortization_simulator": {
+           const P = args.principal;
+           const r = (args.rate || 5) / 1200;
+           const n = (args.termYears || 30) * 12;
+           const monthly = r === 0 ? P / n : (P * r * Math.pow(1 + r, n)) / (Math.pow(1 + r, n) - 1);
+           const totalPayment = monthly * n;
+           const totalInterest = totalPayment - P;
+           res = JSON.stringify({
+             monthlyPayment: monthly.toFixed(2),
+             totalPayment: totalPayment.toFixed(2),
+             totalInterest: totalInterest.toFixed(2)
+           }, null, 2);
+           break;
+        }
+        case "options_pricing_black_scholes": {
+           const S = args.underlyingPrice;
+           const K = args.strikePrice;
+           const T = args.yearsToExpiry;
+           const v = args.volatility;
+           const rf = args.riskFreeRate;
+           const stdNormCDF = (x) => {
+             const b1 = 0.319381530;
+             const b2 = -0.356563782;
+             const b3 = 1.781477937;
+             const b4 = -1.821255978;
+             const b5 = 1.330274429;
+             const p = 0.2316419;
+             const c = 0.39894228;
+             if (x >= 0.0) {
+               const t = 1.0 / (1.0 + p * x);
+               return (1.0 - c * Math.exp(-x * x / 2.0) * t * (t * (t * (t * (t * b5 + b4) + b3) + b2) + b1));
+             } else {
+               const t = 1.0 / (1.0 - p * x);
+               return (c * Math.exp(-x * x / 2.0) * t * (t * (t * (t * (t * b5 + b4) + b3) + b2) + b1));
+             }
+           };
+           const d1 = (Math.log(S / K) + (rf + (v * v) / 2) * T) / (v * Math.sqrt(T));
+           const d2 = d1 - v * Math.sqrt(T);
+           const call = S * stdNormCDF(d1) - K * Math.exp(-rf * T) * stdNormCDF(d2);
+           const put = K * Math.exp(-rf * T) * stdNormCDF(-d2) - S * stdNormCDF(-d1);
+           res = JSON.stringify({
+             callPrice: call.toFixed(4),
+             putPrice: put.toFixed(4)
+           }, null, 2);
+           break;
+        }
+        case "cap_table_dilution": {
+           const preVal = args.preMoneyValuation;
+           const inv = args.investmentAmount;
+           const postVal = preVal + inv;
+           const invPct = inv / postVal;
+           const founderShares = args.founderShares || 1000000;
+           const investorShares = Math.round(founderShares * (invPct / (1 - invPct)));
+           const totalShares = founderShares + investorShares;
+           res = JSON.stringify({
+             postMoneyValuation: postVal,
+             investorOwnershipPercent: (invPct * 100).toFixed(2) + "%",
+             founderShares: founderShares,
+             founderOwnershipPercent: ((founderShares / totalShares) * 100).toFixed(2) + "%",
+             investorShares: investorShares,
+             totalShares: totalShares
+           }, null, 2);
+           break;
+        }
+        case "nda_clause_auditor": {
+           const text = args.text || "";
+           const lowercase = text.toLowerCase();
+           const hasConfidentiality = lowercase.includes("confidential") || lowercase.includes("disclosure");
+           const hasTerm = lowercase.includes("term") || lowercase.includes("termination") || lowercase.includes("duration");
+           const hasNonCompete = lowercase.includes("compete") || lowercase.includes("non-compete");
+           const hasIntellectualProperty = lowercase.includes("intellectual property") || lowercase.includes("proprietary rights") || lowercase.includes("ipr");
+           const hasIndemnification = lowercase.includes("indemnity") || lowercase.includes("indemnify") || lowercase.includes("hold harmless");
+           res = JSON.stringify({
+             auditedCharacters: text.length,
+             confidentialityClause: hasConfidentiality ? "Present" : "Missing / Flagged",
+             termClause: hasTerm ? "Present" : "Missing / Flagged",
+             nonCompeteClause: hasNonCompete ? "Present (Review high-risk non-compete limits)" : "Not Detected",
+             intellectualProperty: hasIntellectualProperty ? "Present" : "Missing / Flagged",
+             indemnification: hasIndemnification ? "Present (Review risk distribution)" : "Not Detected"
+           }, null, 2);
+           break;
+        }
+        case "gdpr_privacy_auditor": {
+           const text = args.text || "";
+           const lowercase = text.toLowerCase();
+           const hasDataController = lowercase.includes("controller") || lowercase.includes("dpo") || lowercase.includes("privacy officer");
+           const hasUserRights = lowercase.includes("access") || lowercase.includes("rectify") || lowercase.includes("erase") || lowercase.includes("deletion") || lowercase.includes("gdpr rights");
+           const hasCookies = lowercase.includes("cookie") || lowercase.includes("tracking") || lowercase.includes("pixels");
+           const hasLegalBasis = lowercase.includes("legal basis") || lowercase.includes("consent") || lowercase.includes("legitimate interest");
+           res = JSON.stringify({
+             dataControllerOrDpo: hasDataController ? "Compliant" : "Needs Review (Missing controller contact)",
+             userRightsEnforcement: hasUserRights ? "Compliant" : "Needs Review (Missing deletion/access rights details)",
+             cookiesDeclaration: hasCookies ? "Compliant" : "Needs Review (Missing cookie statement)",
+             lawfulProcessingBasis: hasLegalBasis ? "Compliant" : "Needs Review (Missing processing justification)"
+           }, null, 2);
+           break;
+        }
+        case "trademark_snippet_compiler": {
+           const license = (args.licenseType || "MIT").toUpperCase();
+           const holder = args.holderName || "ToolBox Co.";
+           const yr = args.year || new Date().getFullYear();
+           if (license === "MIT") {
+             res = `/*\n * MIT License\n * Copyright (c) ${yr} ${holder}\n * Permission is hereby granted, free of charge, to any person obtaining a copy...\n */`;
+           } else {
+             res = `/*\n * Copyright (c) ${yr} ${holder}\n * Licensed under ${license}\n */`;
+           }
+           break;
+        }
+        case "csv_to_sql_ddl": {
+           const csvText = args.csvText || "";
+           const tbl = args.tableName || "temp_table";
+           const lines = csvText.split("\n").map(l => l.trim()).filter(l => l.length);
+           if (!lines.length) throw new Error("CSV text is empty");
+           const headers = lines[0].split(",").map(h => h.replace(/["']/g, "").trim());
+           const createTable = `CREATE TABLE ${tbl} (\n${headers.map(h => `  ${h} VARCHAR(255)`).join(",\n")}\n);`;
+           const rows = lines.slice(1);
+           const inserts = rows.map(r => {
+             const cols = r.split(",").map(c => `'${c.replace(/["']/g, "").replace(/'/g, "''").trim()}'`);
+             return `INSERT INTO ${tbl} (${headers.join(", ")}) VALUES (${cols.join(", ")});`;
+           });
+           res = [createTable, "", ...inserts].join("\n");
+           break;
+        }
+        case "json_schema_to_openapi": {
+           const jsonText = args.jsonText || "{}";
+           const parsed = JSON.parse(jsonText);
+           const generateSchema = (obj) => {
+             if (typeof obj === "string") return { type: "string" };
+             if (typeof obj === "number") return { type: "number" };
+             if (typeof obj === "boolean") return { type: "boolean" };
+             if (Array.isArray(obj)) {
+               return { type: "array", items: obj.length ? generateSchema(obj[0]) : { type: "string" } };
+             }
+             if (typeof obj === "object" && obj !== null) {
+               const properties = {};
+               for (const [k, v] of Object.entries(obj)) {
+                 properties[k] = generateSchema(v);
+               }
+               return { type: "object", properties };
+             }
+             return { type: "string" };
+           };
+           const schema = generateSchema(parsed);
+           const openapi = {
+             openapi: "3.0.0",
+             info: { title: "API Sandbox Generated Specs", version: "1.0.0" },
+             paths: {},
+             components: {
+               schemas: {
+                 GeneratedModel: schema
+               }
+             }
+           };
+           res = JSON.stringify(openapi, null, 2);
+           break;
+        }
+        case "statistical_hypothesis_solver": {
+           const { mean1, mean2, sd1, sd2, n1, n2 } = args;
+           const poolSD = Math.sqrt(((n1 - 1) * sd1 * sd1 + (n2 - 1) * sd2 * sd2) / (n1 + n2 - 2));
+           const tStat = (mean1 - mean2) / (poolSD * Math.sqrt(1 / n1 + 1 / n2));
+           const df = n1 + n2 - 2;
+           const pVal = 2 * (1 - (1 / (1 + Math.exp(-0.07 * Math.pow(Math.abs(tStat), 3) - 1.6 * Math.abs(tStat)))));
+           res = JSON.stringify({
+             tStatistic: tStat.toFixed(4),
+             degreesOfFreedom: df,
+             pValue: pVal.toFixed(6),
+             significance05: pVal < 0.05 ? "Statistically Significant" : "Not Significant"
+           }, null, 2);
+           break;
+        }
+        case "volumetric_shipping_estimator": {
+           const l = args.length;
+           const w = args.width;
+           const h = args.height;
+           const actualWt = args.weight;
+           const div = args.divisor || 139;
+           const volWt = (l * w * h) / div;
+           const billableWt = Math.max(actualWt, volWt);
+           res = JSON.stringify({
+             volumetricWeightLbs: volWt.toFixed(2),
+             actualWeightLbs: actualWt,
+             billableWeightLbs: billableWt.toFixed(2),
+             chargeableMethod: volWt > actualWt ? "Volumetric Dimensional Weight (Over-billed risk)" : "Actual Gross Weight"
+           }, null, 2);
+           break;
+        }
+        case "product_profit_margin": {
+           const cog = args.costOfGoods;
+           const price = args.retailPrice;
+           const marketing = args.marketingSpend || 0;
+           const sold = args.unitsSold || 1;
+           const totalRev = price * sold;
+           const totalCOG = cog * sold;
+           const grossProfit = totalRev - totalCOG;
+           const netProfit = grossProfit - marketing;
+           const netMargin = (netProfit / totalRev) * 100;
+           res = JSON.stringify({
+             totalRevenue: totalRev.toFixed(2),
+             grossProfit: grossProfit.toFixed(2),
+             netProfit: netProfit.toFixed(2),
+             netMarginPercent: netMargin.toFixed(2) + "%",
+             roas: marketing > 0 ? (totalRev / marketing).toFixed(2) : "N/A"
+           }, null, 2);
+           break;
+        }
+        case "ecom_listing_seo_auditor": {
+           const title = args.title || "";
+           const desc = args.description || "";
+           const titleLen = title.length;
+           const descLen = desc.length;
+           res = JSON.stringify({
+             titleLength: titleLen,
+             titleStatus: titleLen >= 50 && titleLen <= 80 ? "Optimized" : "Needs Review (Prefer 50-80 chars)",
+             descriptionLength: descLen,
+             descriptionStatus: descLen > 200 ? "Optimized" : "Needs Review (Prefer >200 chars for depth)"
+           }, null, 2);
+           break;
+        }
+        case "rental_yield_calculator": {
+           const price = args.purchasePrice;
+           const rent = args.monthlyRent;
+           const opex = args.operatingExpenses || 0;
+           const grossRev = rent * 12;
+           const grossYield = (grossRev / price) * 100;
+           const netRev = grossRev - opex;
+           const capRate = (netRev / price) * 100;
+           res = JSON.stringify({
+             grossAnnualRevenue: grossRev.toFixed(2),
+             grossYieldPercent: grossYield.toFixed(2) + "%",
+             netAnnualRevenue: netRev.toFixed(2),
+             capRatePercent: capRate.toFixed(2) + "%"
+           }, null, 2);
+           break;
+        }
+        case "lease_cost_escalation": {
+           const rent = args.baseRent;
+           const esc = args.escalationRate || 3;
+           const years = args.years || 5;
+           const schedule = [];
+           let currentRent = rent;
+           for (let i = 1; i <= years; i++) {
+             schedule.push({ year: i, rent: currentRent.toFixed(2) });
+             currentRent *= (1 + esc / 100);
+           }
+           res = JSON.stringify({
+             finalRent: schedule[schedule.length - 1].rent,
+             schedule
+           }, null, 2);
+           break;
         }
+        case "tabular_synthetic_generator": {
+           const domain = args.domain || "healthcare";
+           const size = args.sampleSize || 10;
+           const rows = [];
+           if (domain === "healthcare") {
+             rows.push("PatientID,Age,SystolicBP,Condition,Treatment");
+             for (let i = 0; i < size; i++) {
+               const bp = Math.round(110 + Math.random() * 35);
+               rows.push(`PT_${1000 + i},${Math.round(20 + Math.random() * 60)},${bp},${bp > 130 ? "Hypertension" : "Healthy"},${bp > 130 ? "Beta-Blockers" : "None"}`);
+             }
+           } else if (domain === "finance") {
+             rows.push("TransactionID,Amount,Country,IsFraud");
+             for (let i = 0; i < size; i++) {
+               const isFraud = Math.random() > 0.92;
+               rows.push(`TX_${2000 + i},${(10 + Math.random() * 1500).toFixed(2)},${["CA", "US", "GB", "NL"][Math.floor(Math.random() * 4)]},${isFraud}`);
+             }
+           } else {
+             rows.push("SessionID,ScrollDepth,ClickCount,Converted");
+             for (let i = 0; i < size; i++) {
+               const converted = Math.random() > 0.85;
+               rows.push(`SESS_${3000 + i},${Math.round(20 + Math.random() * 80)},${Math.round(1 + Math.random() * 12)},${converted}`);
+             }
+           }
+           res = rows.join("\n");
+           break;
+        }
+        case "academic_anonymizer": {
+           const csv = args.csvText || "";
+           const salt = args.salt || "default_salt";
+           const lines = csv.split("\n").map(l => l.trim()).filter(l => l.length);
+           if (!lines.length) throw new Error("CSV text is empty");
+           const headers = lines[0].split(",");
+           const rows = lines.slice(1);
+           const anonymized = [headers.join(",")];
+           for (const r of rows) {
+             const cols = r.split(",");
+             const anonCols = cols.map((col, idx) => {
+               const header = headers[idx]?.toLowerCase() || "";
+               if (header.includes("name") || header.includes("id") || header.includes("email") || header.includes("phone") || header.includes("sin")) {
+                 return crypto.createHash("sha256").update(col + salt).digest("hex").slice(0, 16);
+               }
+               return col;
+             });
+             anonymized.push(anonCols.join(","));
+           }
+           res = anonymized.join("\n");
+           break;
+        }
+        case "hybrid_dataset_fuser": {
+           const csv = args.csvText || "";
+           const mult = args.multiplier || 2;
+           const lines = csv.split("\n").map(l => l.trim()).filter(l => l.length);
+           if (!lines.length) throw new Error("CSV text is empty");
+           const headers = lines[0].split(",");
+           const rows = lines.slice(1);
+           const results = [headers.join(",")];
+           for (let m = 0; m < mult; m++) {
+             for (const r of rows) {
+               const cols = r.split(",");
+               const fusedCols = cols.map((col) => {
+                 const num = Number(col);
+                 if (!isNaN(num)) {
+                   const perturbation = (Math.random() - 0.5) * 0.1 * num;
+                   return (num + perturbation).toFixed(2);
+                 }
+                 return col;
+               });
+               results.push(fusedCols.join(","));
+             }
+           }
+           res = results.join("\n");
+           break;
+        }
+        default: throw new Error(`Tool not found: ${name}`);
+      }
+      return { content: [{ type: "text", text: String(res) }] };
     } catch (e) {
-        console.error("Post error:", e);
+      return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
     }
-}
+  });
 
-async function connectSSE() {
-    console.error(`[ToolBox Bridge] Opening session ${cid} (1.0.8)...`);
-    const res = await fetch(sseInitUrl, { method: 'POST' });
-    
-    const cookies = res.headers.raw()['set-cookie'] || [];
-    for (const c of cookies) {
-        if (c.startsWith('GCRAffinity=')) {
-            gcrCookie = c.split(';')[0];
-        }
-    }
+  return mcpServer;
+}
 
-    if (!res.ok) {
-        console.error(`Failed to connect: ${res.status}`);
-        return;
-    }
+const transports = new Map();
 
-    isConnected = true;
-    console.error(`[ToolBox Bridge] SSE Stream established.`);
+async function setupSseConnection(req, res) {
+  try {
+    let sessionId = req.query.sessionId || req.body?.sessionId || crypto.randomUUID();
+    console.log(`[SSE] Initializing session: ${sessionId}`);
     
-    // Process queue
-    for (const msg of messageQueue) await sendPost(msg);
-    messageQueue.length = 0;
-
-    let buffer = '';
-    for await (const chunk of res.body) {
-        buffer += chunk.toString();
-        const events = buffer.split('\n\n');
-        buffer = events.pop() || '';
-        
-        for (const block of events) {
-            if (!block.trim()) continue;
-            let type = 'message', data = '';
-            for (const line of block.split('\n')) {
-                if (line.startsWith('event:')) type = line.substring(6).trim();
-                else if (line.startsWith('data:')) data += line.substring(5).trim();
-            }
-            if (type === 'message') {
-                process.stdout.write(data + '\n');
-            }
-        }
-    }
+    const transport = new SSEServerTransport(`/message?sessionId=${sessionId}`, res);
+    transports.set(sessionId, transport);
+    console.log(`[SSE] Added ${sessionId} to transports. Total active: ${transports.size}`);
+    
+    const mcpServer = createServer();
+    await mcpServer.connect(transport);
+    console.log(`[SSE] Server connected for ${sessionId}`);
+    
+    req.on('close', () => {
+      console.log(`[SSE] Client CLOSED connection for ${sessionId}. Removing from map.`);
+      transports.delete(sessionId);
+    });
+  } catch (err) {
+    console.error("SSE connection error:", err);
+    if (!res.headersSent) res.status(500).json({ error: "Internal Server Error" });
+  }
 }
 
-connectSSE().catch(e => console.error("SSE Error:", e));
+app.get("/sse", setupSseConnection);
+app.post("/sseInit", setupSseConnection);
 
-const rl = readline.createInterface({ input: process.stdin, terminal: false });
-rl.on('line', async (line) => {
-    if (!line.trim()) return;
-    if (!isConnected) messageQueue.push(line);
-    else await sendPost(line);
+app.post("/message", express.json(), async (req, res) => {
+  const sessionId = req.query.sessionId;
+  let transport = transports.get(sessionId);
+
+  if (!transport) {
+    console.warn(`[POST] Session ${sessionId} not in map. Retrying in 500ms...`);
+    await new Promise(r => setTimeout(r, 500));
+    transport = transports.get(sessionId);
+  }
+
+  if (!transport) {
+    const activeKeys = Array.from(transports.keys());
+    console.error(`[POST] REJECTED 404: Session ${sessionId} still NOT found!`);
+    return res.status(404).send(`Session not found. Map contains: [${activeKeys.join(', ')}]`);
+  }
+
+  await transport.handlePostMessage(req, res, req.body);
 });
 
-setInterval(() => {}, 60000);
+const PORT = process.env.PORT || 8080;
+app.listen(PORT, () => {
+  console.log(`ToolBox Mega MCP Server listening on port ${PORT}`);
+});

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "toolbox-co-mcp-bridge",
-  "version": "1.0.8",
-  "description": "Bridge for ToolBox Co.",
+  "version": "1.0.9",
+  "description": "ToolBox Co MCP Server",
+  "main": "index.js",
   "type": "module",
-  "bin": {
-    "toolbox-co-mcp-bridge": "index.js"
+  "scripts": {
+    "start": "node index.js"
   },
   "dependencies": {
-    "node-fetch": "^3.3.0",
-    "readline": "^1.3.0"
+    "@modelcontextprotocol/sdk": "^1.6.0",
+    "bcryptjs": "^3.0.3",
+    "cors": "^2.8.5",
+    "express": "^4.21.2",
+    "yaml": "^2.8.3"
   }
 }