differino-mcp 0.1.0

package/README.md

@@ -0,0 +1,120 @@
+# differino-mcp
+
+MCP (Model Context Protocol) server for [Differino](https://differino.com) -- compare PDF, DOCX, and TXT documents from any AI agent.
+
+## Setup
+
+### 1. Install
+
+```bash
+cd mcp
+npm install
+npm run build
+```
+
+Or install globally:
+
+```bash
+npm install -g differino-mcp
+```
+
+### 2. Configure
+
+Set environment variables:
+
+```bash
+export DIFFERINO_EMAIL="your@email.com"
+export DIFFERINO_PASSWORD="your-password"
+export SUPABASE_URL="https://your-project.supabase.co"
+export SUPABASE_ANON_KEY="your-anon-key"
+```
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `DIFFERINO_EMAIL` | Yes | Your Differino account email |
+| `DIFFERINO_PASSWORD` | Yes | Your Differino account password |
+| `SUPABASE_URL` | Yes | Supabase project URL (also accepts `DIFFERINO_SUPABASE_URL`) |
+| `SUPABASE_ANON_KEY` | Yes | Supabase anon/public key (also accepts `DIFFERINO_SUPABASE_ANON_KEY`) |
+| `DIFFERINO_URL` | No | Base URL for the web app (default: `https://differino.com`) |
+
+### 3. Add to Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "differino": {
+      "command": "node",
+      "args": ["/path/to/comparadocs/mcp/dist/index.js"],
+      "env": {
+        "DIFFERINO_EMAIL": "your@email.com",
+        "DIFFERINO_PASSWORD": "your-password",
+        "SUPABASE_URL": "https://your-project.supabase.co",
+        "SUPABASE_ANON_KEY": "your-anon-key"
+      }
+    }
+  }
+}
+```
+
+Or if installed globally via npm:
+
+```json
+{
+  "mcpServers": {
+    "differino": {
+      "command": "npx",
+      "args": ["differino-mcp"],
+      "env": {
+        "DIFFERINO_EMAIL": "your@email.com",
+        "DIFFERINO_PASSWORD": "your-password",
+        "SUPABASE_URL": "https://your-project.supabase.co",
+        "SUPABASE_ANON_KEY": "your-anon-key"
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+### compare_documents
+
+Compare two local files and get a diff summary.
+
+**Parameters:**
+- `file_a_path` (required) -- Absolute path to the original document
+- `file_b_path` (required) -- Absolute path to the modified document
+- `accuracy_mode` (optional) -- `fast`, `balanced` (default), or `thorough`
+
+The tool uploads both files, waits for text extraction and diff computation, and returns a summary with added/removed/modified block counts plus a link to the full visual comparison.
+
+Files under 4 MB are uploaded directly. Larger files use a signed-URL flow that bypasses Vercel's body size limit.
+
+### get_comparison
+
+Check the status and results of a comparison by its UUID.
+
+### list_comparisons
+
+List recent comparisons in your workspace (default: 10).
+
+### list_documents
+
+List documents in your Differino library (default: 20).
+
+### get_credits
+
+Check your credit balance, current plan, and free comparison usage for the month.
+
+## Supported Formats
+
+- PDF (.pdf)
+- Word (.docx)
+- Plain Text (.txt)
+
+## Credits
+
+3 free comparisons per month. After that, each comparison costs 1 credit.
+Buy credit packs at [differino.com/pricing](https://differino.com/pricing).

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,568 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const supabase_js_1 = require("@supabase/supabase-js");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+const SUPABASE_URL = process.env.SUPABASE_URL ||
+    process.env.DIFFERINO_SUPABASE_URL ||
+    '';
+const SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY ||
+    process.env.DIFFERINO_SUPABASE_ANON_KEY ||
+    '';
+const BASE_URL = process.env.DIFFERINO_URL || 'https://differino.com';
+const EMAIL = process.env.DIFFERINO_EMAIL || '';
+const PASSWORD = process.env.DIFFERINO_PASSWORD || '';
+let accessToken = null;
+let refreshToken = null;
+let supabase = null;
+// ---------------------------------------------------------------------------
+// Auth helpers
+// ---------------------------------------------------------------------------
+async function authenticate() {
+    supabase = (0, supabase_js_1.createClient)(SUPABASE_URL, SUPABASE_ANON_KEY);
+    const { data, error } = await supabase.auth.signInWithPassword({
+        email: EMAIL,
+        password: PASSWORD,
+    });
+    if (error)
+        throw new Error(`Authentication failed: ${error.message}`);
+    accessToken = data.session.access_token;
+    refreshToken = data.session.refresh_token;
+}
+async function ensureAuth() {
+    if (!supabase || !accessToken) {
+        await authenticate();
+    }
+    return supabase;
+}
+/**
+ * Build the cookie header that the Next.js Supabase SSR client expects.
+ *
+ * @supabase/ssr stores the session in a cookie whose name follows the pattern
+ * `sb-<project-ref>-auth-token`. The value is a base64url-encoded JSON string
+ * containing `access_token`, `refresh_token`, etc.
+ *
+ * For large tokens the library may chunk the cookie across multiple numbered
+ * cookies (sb-<ref>-auth-token.0, .1, ...). We produce a single cookie here
+ * which works for typical token sizes.
+ */
+function buildAuthCookie() {
+    const projectRef = SUPABASE_URL.match(/https:\/\/([^.]+)\./)?.[1] || 'ref';
+    const cookieName = `sb-${projectRef}-auth-token`;
+    const cookieValue = JSON.stringify({
+        access_token: accessToken,
+        refresh_token: refreshToken,
+        token_type: 'bearer',
+    });
+    // The SSR helper may also check chunked variants (.0, .1, …).
+    // Providing a single non-chunked cookie is accepted when the value fits in
+    // one cookie (< 3180 bytes). For very long JWTs we split into chunks.
+    const encoded = cookieValue;
+    const CHUNK_SIZE = 3180;
+    if (encoded.length <= CHUNK_SIZE) {
+        return `${cookieName}=${encodeURIComponent(encoded)}`;
+    }
+    // Chunked cookies
+    const chunks = [];
+    for (let i = 0; i * CHUNK_SIZE < encoded.length; i++) {
+        const slice = encoded.substring(i * CHUNK_SIZE, (i + 1) * CHUNK_SIZE);
+        chunks.push(`${cookieName}.${i}=${encodeURIComponent(slice)}`);
+    }
+    return chunks.join('; ');
+}
+// ---------------------------------------------------------------------------
+// HTTP helpers (calls to the Differino Next.js API)
+// ---------------------------------------------------------------------------
+async function apiCall(endpoint, options = {}) {
+    const url = `${BASE_URL}${endpoint}`;
+    const headers = {
+        ...(options.headers || {}),
+    };
+    if (accessToken) {
+        headers['Cookie'] = buildAuthCookie();
+    }
+    const res = await fetch(url, { ...options, headers, redirect: 'manual' });
+    // Handle redirects (auth middleware may redirect to /login)
+    if (res.status >= 300 && res.status < 400) {
+        throw new Error(`API redirected (${res.status}) — session may have expired. Location: ${res.headers.get('location')}`);
+    }
+    const text = await res.text();
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Non-JSON response from ${endpoint}: ${text.slice(0, 200)}`);
+    }
+    if (!res.ok) {
+        throw new Error(json.error || `API error ${res.status}: ${text.slice(0, 300)}`);
+    }
+    return json;
+}
+// ---------------------------------------------------------------------------
+// File utilities
+// ---------------------------------------------------------------------------
+const SUPPORTED_EXTENSIONS = new Set(['pdf', 'docx', 'txt']);
+function getExtension(filename) {
+    return (filename.split('.').pop() || '').toLowerCase();
+}
+function getMimeType(ext) {
+    switch (ext) {
+        case 'pdf':
+            return 'application/pdf';
+        case 'docx':
+            return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+        case 'txt':
+            return 'text/plain';
+        default:
+            return 'application/octet-stream';
+    }
+}
+// ---------------------------------------------------------------------------
+// Tool implementations
+// ---------------------------------------------------------------------------
+async function compareDocuments(args) {
+    await ensureAuth();
+    const { file_a_path, file_b_path, accuracy_mode = 'balanced' } = args;
+    // --- Validate files ---
+    for (const fp of [file_a_path, file_b_path]) {
+        if (!fs.existsSync(fp)) {
+            return `Error: File not found: ${fp}`;
+        }
+    }
+    const nameA = path.basename(file_a_path);
+    const nameB = path.basename(file_b_path);
+    const extA = getExtension(nameA);
+    const extB = getExtension(nameB);
+    if (!SUPPORTED_EXTENSIONS.has(extA)) {
+        return `Error: Unsupported file type for ${nameA}. Supported: PDF, DOCX, TXT.`;
+    }
+    if (!SUPPORTED_EXTENSIONS.has(extB)) {
+        return `Error: Unsupported file type for ${nameB}. Supported: PDF, DOCX, TXT.`;
+    }
+    // --- Upload file A ---
+    const fileABuffer = fs.readFileSync(file_a_path);
+    const fileASize = fileABuffer.byteLength;
+    // Use init/complete flow for files > 4MB, direct upload for smaller ones
+    let uploadA;
+    let uploadB;
+    if (fileASize < 4 * 1024 * 1024) {
+        // Direct upload via /api/upload
+        const formA = new FormData();
+        formA.append('file', new Blob([fileABuffer], { type: getMimeType(extA) }), nameA);
+        formA.append('name', nameA);
+        uploadA = await apiCall('/api/upload', {
+            method: 'POST',
+            body: formA,
+        });
+    }
+    else {
+        uploadA = await uploadLargeFile(file_a_path, nameA, fileABuffer, extA);
+    }
+    // --- Upload file B ---
+    const fileBBuffer = fs.readFileSync(file_b_path);
+    const fileBSize = fileBBuffer.byteLength;
+    if (fileBSize < 4 * 1024 * 1024) {
+        const formB = new FormData();
+        formB.append('file', new Blob([fileBBuffer], { type: getMimeType(extB) }), nameB);
+        formB.append('name', nameB);
+        uploadB = await apiCall('/api/upload', {
+            method: 'POST',
+            body: formB,
+        });
+    }
+    else {
+        uploadB = await uploadLargeFile(file_b_path, nameB, fileBBuffer, extB);
+    }
+    // --- Wait for text extraction ---
+    const MAX_WAIT_MS = 120_000;
+    const POLL_MS = 2_000;
+    for (const vId of [uploadA.versionId, uploadB.versionId]) {
+        const deadline = Date.now() + MAX_WAIT_MS;
+        while (Date.now() < deadline) {
+            const { data } = await supabase
+                .from('versions')
+                .select('status')
+                .eq('id', vId)
+                .single();
+            if (data?.status === 'ready')
+                break;
+            if (data?.status === 'failed') {
+                return `Error: Text extraction failed for version ${vId}.`;
+            }
+            await sleep(POLL_MS);
+        }
+    }
+    // --- Create comparison ---
+    const comparison = await apiCall('/api/comparisons', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            versionAId: uploadA.versionId,
+            versionBId: uploadB.versionId,
+            accuracyMode: accuracy_mode,
+        }),
+    });
+    // --- Poll for comparison result ---
+    const compDeadline = Date.now() + MAX_WAIT_MS;
+    while (Date.now() < compDeadline) {
+        const { data } = await supabase
+            .from('comparisons')
+            .select('status, summary, error_message')
+            .eq('id', comparison.id)
+            .single();
+        if (data?.status === 'ready') {
+            const summary = data.summary;
+            return JSON.stringify({
+                status: 'ready',
+                comparison_id: comparison.id,
+                url: `${BASE_URL}/compare?id=${comparison.id}`,
+                summary: {
+                    added_blocks: summary?.added_blocks ?? 0,
+                    removed_blocks: summary?.removed_blocks ?? 0,
+                    modified_blocks: summary?.modified_blocks ?? 0,
+                    unchanged_blocks: summary?.unchanged_blocks ?? 0,
+                },
+            }, null, 2);
+        }
+        if (data?.status === 'failed') {
+            return `Error: Comparison failed — ${data.error_message || 'unknown error'}`;
+        }
+        await sleep(POLL_MS);
+    }
+    return JSON.stringify({
+        status: 'processing',
+        comparison_id: comparison.id,
+        url: `${BASE_URL}/compare?id=${comparison.id}`,
+        message: 'Comparison is still processing. Check the URL for results.',
+    }, null, 2);
+}
+/**
+ * Upload a large file (>4 MB) via the init + signed-URL + complete flow,
+ * which bypasses Vercel's 4.5 MB request body limit.
+ */
+async function uploadLargeFile(filePath, filename, buffer, ext) {
+    const mime = getMimeType(ext);
+    // 1. Init — creates version record and returns a signed upload URL
+    const init = await apiCall('/api/upload/init', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            filename,
+            contentType: mime,
+            fileSize: buffer.byteLength,
+            documentName: filename,
+        }),
+    });
+    // 2. Upload directly to Supabase Storage via the signed URL
+    const uploadRes = await fetch(init.signedUrl, {
+        method: 'PUT',
+        headers: { 'Content-Type': mime },
+        body: new Uint8Array(buffer),
+    });
+    if (!uploadRes.ok) {
+        const text = await uploadRes.text();
+        throw new Error(`Storage upload failed (${uploadRes.status}): ${text.slice(0, 200)}`);
+    }
+    // 3. Complete — enqueues extraction job
+    const complete = await apiCall('/api/upload/complete', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ versionId: init.versionId }),
+    });
+    return {
+        versionId: init.versionId,
+        documentId: init.documentId,
+    };
+}
+async function getComparison(args) {
+    await ensureAuth();
+    const { data, error } = await supabase
+        .from('comparisons')
+        .select(`
+      id, status, summary, error_message, created_at, completed_at,
+      version_a:versions!version_a_id ( id, document_id, documents ( name ) ),
+      version_b:versions!version_b_id ( id, document_id, documents ( name ) )
+    `)
+        .eq('id', args.comparison_id)
+        .single();
+    if (error || !data)
+        return 'Error: Comparison not found.';
+    const rec = data;
+    return JSON.stringify({
+        comparison_id: rec.id,
+        status: rec.status,
+        url: `${BASE_URL}/compare?id=${rec.id}`,
+        file_a: rec.version_a?.documents?.name ?? 'Unknown',
+        file_b: rec.version_b?.documents?.name ?? 'Unknown',
+        summary: rec.summary ?? null,
+        error: rec.error_message ?? null,
+        created_at: rec.created_at,
+        completed_at: rec.completed_at,
+    }, null, 2);
+}
+async function listComparisons(args) {
+    await ensureAuth();
+    const limit = args.limit || 10;
+    const { data: workspace } = await supabase
+        .from('workspaces')
+        .select('id')
+        .single();
+    if (!workspace)
+        return 'Error: No workspace found.';
+    const { data, error } = await supabase
+        .from('comparisons')
+        .select(`
+      id, status, created_at,
+      version_a:versions!version_a_id ( documents ( name ) ),
+      version_b:versions!version_b_id ( documents ( name ) )
+    `)
+        .eq('workspace_id', workspace.id)
+        .order('created_at', { ascending: false })
+        .limit(limit);
+    if (error)
+        return `Error: ${error.message}`;
+    const comparisons = (data || []).map((c) => ({
+        id: c.id,
+        status: c.status,
+        file_a: c.version_a?.documents?.name ?? 'Unknown',
+        file_b: c.version_b?.documents?.name ?? 'Unknown',
+        created_at: c.created_at,
+        url: `${BASE_URL}/compare?id=${c.id}`,
+    }));
+    return JSON.stringify(comparisons, null, 2);
+}
+async function listDocuments(args) {
+    await ensureAuth();
+    const { data: workspace } = await supabase
+        .from('workspaces')
+        .select('id')
+        .single();
+    if (!workspace)
+        return 'Error: No workspace found.';
+    const { data, error } = await supabase
+        .from('documents')
+        .select(`
+      id, name, updated_at,
+      versions ( id, version_number, status, created_at )
+    `)
+        .eq('workspace_id', workspace.id)
+        .order('updated_at', { ascending: false })
+        .limit(args.limit || 20);
+    if (error)
+        return `Error: ${error.message}`;
+    return JSON.stringify(data, null, 2);
+}
+async function getCredits() {
+    await ensureAuth();
+    const { data: workspace } = await supabase
+        .from('workspaces')
+        .select('credits, plan, pro_expires_at')
+        .single();
+    if (!workspace)
+        return 'Error: No workspace found.';
+    const now = new Date();
+    const monthKey = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-01`;
+    const { data: usage } = await supabase
+        .from('usage')
+        .select('comparison_count')
+        .eq('month', monthKey)
+        .single();
+    return JSON.stringify({
+        credits: workspace.credits,
+        plan: workspace.plan,
+        pro_expires_at: workspace.pro_expires_at,
+        free_comparisons_used: usage?.comparison_count ?? 0,
+        free_comparisons_limit: 3,
+    }, null, 2);
+}
+// ---------------------------------------------------------------------------
+// Utility
+// ---------------------------------------------------------------------------
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
+const server = new index_js_1.Server({ name: 'differino', version: '0.1.0' }, { capabilities: { tools: {} } });
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: 'compare_documents',
+            description: 'Compare two documents (PDF, DOCX, or TXT) and see the differences. ' +
+                'Reads files from local disk, uploads them to Differino, and returns a diff summary.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    file_a_path: {
+                        type: 'string',
+                        description: 'Absolute path to the original document',
+                    },
+                    file_b_path: {
+                        type: 'string',
+                        description: 'Absolute path to the modified document',
+                    },
+                    accuracy_mode: {
+                        type: 'string',
+                        enum: ['fast', 'balanced', 'thorough'],
+                        description: 'Comparison accuracy mode (default: balanced)',
+                    },
+                },
+                required: ['file_a_path', 'file_b_path'],
+            },
+        },
+        {
+            name: 'get_comparison',
+            description: 'Get the status and results of a specific comparison by its ID.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    comparison_id: {
+                        type: 'string',
+                        description: 'The comparison UUID',
+                    },
+                },
+                required: ['comparison_id'],
+            },
+        },
+        {
+            name: 'list_comparisons',
+            description: 'List recent document comparisons in the user\'s workspace.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of comparisons to return (default: 10)',
+                    },
+                },
+            },
+        },
+        {
+            name: 'list_documents',
+            description: 'List documents in the user\'s Differino library.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of documents to return (default: 20)',
+                    },
+                },
+            },
+        },
+        {
+            name: 'get_credits',
+            description: 'Check the user\'s credit balance, plan status, and free comparison usage for the current month.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        },
+    ],
+}));
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        let result;
+        switch (name) {
+            case 'compare_documents':
+                result = await compareDocuments(args);
+                break;
+            case 'get_comparison':
+                result = await getComparison(args);
+                break;
+            case 'list_comparisons':
+                result = await listComparisons(args);
+                break;
+            case 'list_documents':
+                result = await listDocuments(args);
+                break;
+            case 'get_credits':
+                result = await getCredits();
+                break;
+            default:
+                result = `Unknown tool: ${name}`;
+        }
+        return {
+            content: [{ type: 'text', text: result }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+async function main() {
+    // Validate required env vars
+    if (!EMAIL || !PASSWORD) {
+        console.error('Error: DIFFERINO_EMAIL and DIFFERINO_PASSWORD environment variables are required.');
+        process.exit(1);
+    }
+    if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
+        console.error('Error: SUPABASE_URL and SUPABASE_ANON_KEY environment variables are required.');
+        process.exit(1);
+    }
+    // Authenticate on startup so we fail fast if credentials are wrong
+    try {
+        await authenticate();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(message);
+        process.exit(1);
+    }
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "differino-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Differino document comparison",
+  "main": "dist/index.js",
+  "bin": {
+    "differino-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@supabase/supabase-js": "^2.39.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,660 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { createClient, SupabaseClient } from '@supabase/supabase-js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+const SUPABASE_URL =
+  process.env.SUPABASE_URL ||
+  process.env.DIFFERINO_SUPABASE_URL ||
+  '';
+const SUPABASE_ANON_KEY =
+  process.env.SUPABASE_ANON_KEY ||
+  process.env.DIFFERINO_SUPABASE_ANON_KEY ||
+  '';
+const BASE_URL = process.env.DIFFERINO_URL || 'https://differino.com';
+const EMAIL = process.env.DIFFERINO_EMAIL || '';
+const PASSWORD = process.env.DIFFERINO_PASSWORD || '';
+
+let accessToken: string | null = null;
+let refreshToken: string | null = null;
+let supabase: SupabaseClient | null = null;
+
+// ---------------------------------------------------------------------------
+// Auth helpers
+// ---------------------------------------------------------------------------
+
+async function authenticate(): Promise<void> {
+  supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
+  const { data, error } = await supabase.auth.signInWithPassword({
+    email: EMAIL,
+    password: PASSWORD,
+  });
+  if (error) throw new Error(`Authentication failed: ${error.message}`);
+  accessToken = data.session.access_token;
+  refreshToken = data.session.refresh_token;
+}
+
+async function ensureAuth(): Promise<SupabaseClient> {
+  if (!supabase || !accessToken) {
+    await authenticate();
+  }
+  return supabase!;
+}
+
+/**
+ * Build the cookie header that the Next.js Supabase SSR client expects.
+ *
+ * @supabase/ssr stores the session in a cookie whose name follows the pattern
+ * `sb-<project-ref>-auth-token`. The value is a base64url-encoded JSON string
+ * containing `access_token`, `refresh_token`, etc.
+ *
+ * For large tokens the library may chunk the cookie across multiple numbered
+ * cookies (sb-<ref>-auth-token.0, .1, ...). We produce a single cookie here
+ * which works for typical token sizes.
+ */
+function buildAuthCookie(): string {
+  const projectRef = SUPABASE_URL.match(/https:\/\/([^.]+)\./)?.[1] || 'ref';
+  const cookieName = `sb-${projectRef}-auth-token`;
+  const cookieValue = JSON.stringify({
+    access_token: accessToken,
+    refresh_token: refreshToken,
+    token_type: 'bearer',
+  });
+
+  // The SSR helper may also check chunked variants (.0, .1, …).
+  // Providing a single non-chunked cookie is accepted when the value fits in
+  // one cookie (< 3180 bytes). For very long JWTs we split into chunks.
+  const encoded = cookieValue;
+  const CHUNK_SIZE = 3180;
+
+  if (encoded.length <= CHUNK_SIZE) {
+    return `${cookieName}=${encodeURIComponent(encoded)}`;
+  }
+
+  // Chunked cookies
+  const chunks: string[] = [];
+  for (let i = 0; i * CHUNK_SIZE < encoded.length; i++) {
+    const slice = encoded.substring(i * CHUNK_SIZE, (i + 1) * CHUNK_SIZE);
+    chunks.push(`${cookieName}.${i}=${encodeURIComponent(slice)}`);
+  }
+  return chunks.join('; ');
+}
+
+// ---------------------------------------------------------------------------
+// HTTP helpers (calls to the Differino Next.js API)
+// ---------------------------------------------------------------------------
+
+async function apiCall(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<any> {
+  const url = `${BASE_URL}${endpoint}`;
+  const headers: Record<string, string> = {
+    ...(options.headers as Record<string, string> || {}),
+  };
+
+  if (accessToken) {
+    headers['Cookie'] = buildAuthCookie();
+  }
+
+  const res = await fetch(url, { ...options, headers, redirect: 'manual' });
+
+  // Handle redirects (auth middleware may redirect to /login)
+  if (res.status >= 300 && res.status < 400) {
+    throw new Error(
+      `API redirected (${res.status}) — session may have expired. Location: ${res.headers.get('location')}`,
+    );
+  }
+
+  const text = await res.text();
+  let json: any;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new Error(`Non-JSON response from ${endpoint}: ${text.slice(0, 200)}`);
+  }
+
+  if (!res.ok) {
+    throw new Error(json.error || `API error ${res.status}: ${text.slice(0, 300)}`);
+  }
+
+  return json;
+}
+
+// ---------------------------------------------------------------------------
+// File utilities
+// ---------------------------------------------------------------------------
+
+const SUPPORTED_EXTENSIONS = new Set(['pdf', 'docx', 'txt']);
+
+function getExtension(filename: string): string {
+  return (filename.split('.').pop() || '').toLowerCase();
+}
+
+function getMimeType(ext: string): string {
+  switch (ext) {
+    case 'pdf':
+      return 'application/pdf';
+    case 'docx':
+      return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+    case 'txt':
+      return 'text/plain';
+    default:
+      return 'application/octet-stream';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tool implementations
+// ---------------------------------------------------------------------------
+
+async function compareDocuments(args: {
+  file_a_path: string;
+  file_b_path: string;
+  accuracy_mode?: string;
+}): Promise<string> {
+  await ensureAuth();
+
+  const { file_a_path, file_b_path, accuracy_mode = 'balanced' } = args;
+
+  // --- Validate files ---
+  for (const fp of [file_a_path, file_b_path]) {
+    if (!fs.existsSync(fp)) {
+      return `Error: File not found: ${fp}`;
+    }
+  }
+
+  const nameA = path.basename(file_a_path);
+  const nameB = path.basename(file_b_path);
+  const extA = getExtension(nameA);
+  const extB = getExtension(nameB);
+
+  if (!SUPPORTED_EXTENSIONS.has(extA)) {
+    return `Error: Unsupported file type for ${nameA}. Supported: PDF, DOCX, TXT.`;
+  }
+  if (!SUPPORTED_EXTENSIONS.has(extB)) {
+    return `Error: Unsupported file type for ${nameB}. Supported: PDF, DOCX, TXT.`;
+  }
+
+  // --- Upload file A ---
+  const fileABuffer = fs.readFileSync(file_a_path);
+  const fileASize = fileABuffer.byteLength;
+
+  // Use init/complete flow for files > 4MB, direct upload for smaller ones
+  let uploadA: { versionId: string; documentId: string };
+  let uploadB: { versionId: string; documentId: string };
+
+  if (fileASize < 4 * 1024 * 1024) {
+    // Direct upload via /api/upload
+    const formA = new FormData();
+    formA.append('file', new Blob([fileABuffer], { type: getMimeType(extA) }), nameA);
+    formA.append('name', nameA);
+
+    uploadA = await apiCall('/api/upload', {
+      method: 'POST',
+      body: formA,
+    });
+  } else {
+    uploadA = await uploadLargeFile(file_a_path, nameA, fileABuffer, extA);
+  }
+
+  // --- Upload file B ---
+  const fileBBuffer = fs.readFileSync(file_b_path);
+  const fileBSize = fileBBuffer.byteLength;
+
+  if (fileBSize < 4 * 1024 * 1024) {
+    const formB = new FormData();
+    formB.append('file', new Blob([fileBBuffer], { type: getMimeType(extB) }), nameB);
+    formB.append('name', nameB);
+
+    uploadB = await apiCall('/api/upload', {
+      method: 'POST',
+      body: formB,
+    });
+  } else {
+    uploadB = await uploadLargeFile(file_b_path, nameB, fileBBuffer, extB);
+  }
+
+  // --- Wait for text extraction ---
+  const MAX_WAIT_MS = 120_000;
+  const POLL_MS = 2_000;
+
+  for (const vId of [uploadA.versionId, uploadB.versionId]) {
+    const deadline = Date.now() + MAX_WAIT_MS;
+    while (Date.now() < deadline) {
+      const { data } = await supabase!
+        .from('versions')
+        .select('status')
+        .eq('id', vId)
+        .single();
+
+      if (data?.status === 'ready') break;
+      if (data?.status === 'failed') {
+        return `Error: Text extraction failed for version ${vId}.`;
+      }
+
+      await sleep(POLL_MS);
+    }
+  }
+
+  // --- Create comparison ---
+  const comparison = await apiCall('/api/comparisons', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      versionAId: uploadA.versionId,
+      versionBId: uploadB.versionId,
+      accuracyMode: accuracy_mode,
+    }),
+  });
+
+  // --- Poll for comparison result ---
+  const compDeadline = Date.now() + MAX_WAIT_MS;
+  while (Date.now() < compDeadline) {
+    const { data } = await supabase!
+      .from('comparisons')
+      .select('status, summary, error_message')
+      .eq('id', comparison.id)
+      .single();
+
+    if (data?.status === 'ready') {
+      const summary = data.summary as Record<string, number> | null;
+      return JSON.stringify(
+        {
+          status: 'ready',
+          comparison_id: comparison.id,
+          url: `${BASE_URL}/compare?id=${comparison.id}`,
+          summary: {
+            added_blocks: summary?.added_blocks ?? 0,
+            removed_blocks: summary?.removed_blocks ?? 0,
+            modified_blocks: summary?.modified_blocks ?? 0,
+            unchanged_blocks: summary?.unchanged_blocks ?? 0,
+          },
+        },
+        null,
+        2,
+      );
+    }
+
+    if (data?.status === 'failed') {
+      return `Error: Comparison failed — ${data.error_message || 'unknown error'}`;
+    }
+
+    await sleep(POLL_MS);
+  }
+
+  return JSON.stringify(
+    {
+      status: 'processing',
+      comparison_id: comparison.id,
+      url: `${BASE_URL}/compare?id=${comparison.id}`,
+      message: 'Comparison is still processing. Check the URL for results.',
+    },
+    null,
+    2,
+  );
+}
+
+/**
+ * Upload a large file (>4 MB) via the init + signed-URL + complete flow,
+ * which bypasses Vercel's 4.5 MB request body limit.
+ */
+async function uploadLargeFile(
+  filePath: string,
+  filename: string,
+  buffer: Buffer,
+  ext: string,
+): Promise<{ versionId: string; documentId: string }> {
+  const mime = getMimeType(ext);
+
+  // 1. Init — creates version record and returns a signed upload URL
+  const init = await apiCall('/api/upload/init', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      filename,
+      contentType: mime,
+      fileSize: buffer.byteLength,
+      documentName: filename,
+    }),
+  });
+
+  // 2. Upload directly to Supabase Storage via the signed URL
+  const uploadRes = await fetch(init.signedUrl, {
+    method: 'PUT',
+    headers: { 'Content-Type': mime },
+    body: new Uint8Array(buffer),
+  });
+
+  if (!uploadRes.ok) {
+    const text = await uploadRes.text();
+    throw new Error(`Storage upload failed (${uploadRes.status}): ${text.slice(0, 200)}`);
+  }
+
+  // 3. Complete — enqueues extraction job
+  const complete = await apiCall('/api/upload/complete', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ versionId: init.versionId }),
+  });
+
+  return {
+    versionId: init.versionId,
+    documentId: init.documentId,
+  };
+}
+
+async function getComparison(args: { comparison_id: string }): Promise<string> {
+  await ensureAuth();
+
+  const { data, error } = await supabase!
+    .from('comparisons')
+    .select(
+      `
+      id, status, summary, error_message, created_at, completed_at,
+      version_a:versions!version_a_id ( id, document_id, documents ( name ) ),
+      version_b:versions!version_b_id ( id, document_id, documents ( name ) )
+    `,
+    )
+    .eq('id', args.comparison_id)
+    .single();
+
+  if (error || !data) return 'Error: Comparison not found.';
+
+  const rec = data as any;
+  return JSON.stringify(
+    {
+      comparison_id: rec.id,
+      status: rec.status,
+      url: `${BASE_URL}/compare?id=${rec.id}`,
+      file_a: rec.version_a?.documents?.name ?? 'Unknown',
+      file_b: rec.version_b?.documents?.name ?? 'Unknown',
+      summary: rec.summary ?? null,
+      error: rec.error_message ?? null,
+      created_at: rec.created_at,
+      completed_at: rec.completed_at,
+    },
+    null,
+    2,
+  );
+}
+
+async function listComparisons(args: { limit?: number }): Promise<string> {
+  await ensureAuth();
+
+  const limit = args.limit || 10;
+
+  const { data: workspace } = await supabase!
+    .from('workspaces')
+    .select('id')
+    .single();
+
+  if (!workspace) return 'Error: No workspace found.';
+
+  const { data, error } = await supabase!
+    .from('comparisons')
+    .select(
+      `
+      id, status, created_at,
+      version_a:versions!version_a_id ( documents ( name ) ),
+      version_b:versions!version_b_id ( documents ( name ) )
+    `,
+    )
+    .eq('workspace_id', workspace.id)
+    .order('created_at', { ascending: false })
+    .limit(limit);
+
+  if (error) return `Error: ${error.message}`;
+
+  const comparisons = (data || []).map((c: any) => ({
+    id: c.id,
+    status: c.status,
+    file_a: c.version_a?.documents?.name ?? 'Unknown',
+    file_b: c.version_b?.documents?.name ?? 'Unknown',
+    created_at: c.created_at,
+    url: `${BASE_URL}/compare?id=${c.id}`,
+  }));
+
+  return JSON.stringify(comparisons, null, 2);
+}
+
+async function listDocuments(args: { limit?: number }): Promise<string> {
+  await ensureAuth();
+
+  const { data: workspace } = await supabase!
+    .from('workspaces')
+    .select('id')
+    .single();
+
+  if (!workspace) return 'Error: No workspace found.';
+
+  const { data, error } = await supabase!
+    .from('documents')
+    .select(
+      `
+      id, name, updated_at,
+      versions ( id, version_number, status, created_at )
+    `,
+    )
+    .eq('workspace_id', workspace.id)
+    .order('updated_at', { ascending: false })
+    .limit(args.limit || 20);
+
+  if (error) return `Error: ${error.message}`;
+
+  return JSON.stringify(data, null, 2);
+}
+
+async function getCredits(): Promise<string> {
+  await ensureAuth();
+
+  const { data: workspace } = await supabase!
+    .from('workspaces')
+    .select('credits, plan, pro_expires_at')
+    .single();
+
+  if (!workspace) return 'Error: No workspace found.';
+
+  const now = new Date();
+  const monthKey = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-01`;
+
+  const { data: usage } = await supabase!
+    .from('usage')
+    .select('comparison_count')
+    .eq('month', monthKey)
+    .single();
+
+  return JSON.stringify(
+    {
+      credits: (workspace as any).credits,
+      plan: (workspace as any).plan,
+      pro_expires_at: (workspace as any).pro_expires_at,
+      free_comparisons_used: (usage as any)?.comparison_count ?? 0,
+      free_comparisons_limit: 3,
+    },
+    null,
+    2,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Utility
+// ---------------------------------------------------------------------------
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
+
+const server = new Server(
+  { name: 'differino', version: '0.1.0' },
+  { capabilities: { tools: {} } },
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'compare_documents',
+      description:
+        'Compare two documents (PDF, DOCX, or TXT) and see the differences. ' +
+        'Reads files from local disk, uploads them to Differino, and returns a diff summary.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          file_a_path: {
+            type: 'string',
+            description: 'Absolute path to the original document',
+          },
+          file_b_path: {
+            type: 'string',
+            description: 'Absolute path to the modified document',
+          },
+          accuracy_mode: {
+            type: 'string',
+            enum: ['fast', 'balanced', 'thorough'],
+            description: 'Comparison accuracy mode (default: balanced)',
+          },
+        },
+        required: ['file_a_path', 'file_b_path'],
+      },
+    },
+    {
+      name: 'get_comparison',
+      description: 'Get the status and results of a specific comparison by its ID.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          comparison_id: {
+            type: 'string',
+            description: 'The comparison UUID',
+          },
+        },
+        required: ['comparison_id'],
+      },
+    },
+    {
+      name: 'list_comparisons',
+      description: 'List recent document comparisons in the user\'s workspace.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          limit: {
+            type: 'number',
+            description: 'Maximum number of comparisons to return (default: 10)',
+          },
+        },
+      },
+    },
+    {
+      name: 'list_documents',
+      description: 'List documents in the user\'s Differino library.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          limit: {
+            type: 'number',
+            description: 'Maximum number of documents to return (default: 20)',
+          },
+        },
+      },
+    },
+    {
+      name: 'get_credits',
+      description:
+        'Check the user\'s credit balance, plan status, and free comparison usage for the current month.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {},
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    let result: string;
+
+    switch (name) {
+      case 'compare_documents':
+        result = await compareDocuments(args as any);
+        break;
+      case 'get_comparison':
+        result = await getComparison(args as any);
+        break;
+      case 'list_comparisons':
+        result = await listComparisons(args as any);
+        break;
+      case 'list_documents':
+        result = await listDocuments(args as any);
+        break;
+      case 'get_credits':
+        result = await getCredits();
+        break;
+      default:
+        result = `Unknown tool: ${name}`;
+    }
+
+    return {
+      content: [{ type: 'text', text: result }],
+    };
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      content: [{ type: 'text', text: `Error: ${message}` }],
+      isError: true,
+    };
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  // Validate required env vars
+  if (!EMAIL || !PASSWORD) {
+    console.error(
+      'Error: DIFFERINO_EMAIL and DIFFERINO_PASSWORD environment variables are required.',
+    );
+    process.exit(1);
+  }
+  if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
+    console.error(
+      'Error: SUPABASE_URL and SUPABASE_ANON_KEY environment variables are required.',
+    );
+    process.exit(1);
+  }
+
+  // Authenticate on startup so we fail fast if credentials are wrong
+  try {
+    await authenticate();
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(message);
+    process.exit(1);
+  }
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}