screenpipe-mcp 0.3.1 → 0.4.1

package/dist/export-video.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/export-video.test.js

@@ -0,0 +1,348 @@
+"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 vitest_1 = require("vitest");
+const ws_1 = __importStar(require("ws"));
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// Mock the search API response
+function createMockSearchResponse(frameIds) {
+    return {
+        data: frameIds.map((id, index) => ({
+            type: "OCR",
+            content: {
+                frame_id: id,
+                text: `Screen content ${index}`,
+                timestamp: new Date(Date.now() - (frameIds.length - index) * 60000).toISOString(),
+                app_name: "Test App",
+                window_name: "Test Window",
+            },
+        })),
+    };
+}
+// Mock video export progress messages
+function createExportProgressMessages(frameCount) {
+    const messages = [];
+    // Extracting phase
+    for (let i = 0; i <= 10; i++) {
+        messages.push(JSON.stringify({
+            status: "extracting",
+            progress: (i / 10) * 0.5,
+            video_data: null,
+            error: null,
+        }));
+    }
+    // Encoding phase
+    for (let i = 0; i <= 10; i++) {
+        messages.push(JSON.stringify({
+            status: "encoding",
+            progress: 0.5 + (i / 10) * 0.5,
+            video_data: null,
+            error: null,
+        }));
+    }
+    return messages;
+}
+(0, vitest_1.describe)("export-video MCP tool", () => {
+    let mockHttpServer;
+    let mockWsServer;
+    let serverPort;
+    (0, vitest_1.beforeEach)(async () => {
+        // Create a mock HTTP server for the search API
+        mockHttpServer = http.createServer((req, res) => {
+            const url = new URL(req.url, `http://localhost`);
+            if (url.pathname === "/search") {
+                const startTime = url.searchParams.get("start_time");
+                const endTime = url.searchParams.get("end_time");
+                const contentType = url.searchParams.get("content_type");
+                // Validate required parameters
+                if (!startTime || !endTime) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Missing time parameters" }));
+                    return;
+                }
+                // Return mock search results with frame IDs
+                const mockResponse = createMockSearchResponse([100, 101, 102, 103, 104]);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(mockResponse));
+            }
+            else {
+                res.writeHead(404);
+                res.end();
+            }
+        });
+        // Create WebSocket server for export endpoint
+        mockWsServer = new ws_1.WebSocketServer({ noServer: true });
+        mockHttpServer.on("upgrade", (request, socket, head) => {
+            const url = new URL(request.url, `http://localhost`);
+            if (url.pathname === "/frames/export") {
+                mockWsServer.handleUpgrade(request, socket, head, (ws) => {
+                    // Send progress updates
+                    const progressMessages = createExportProgressMessages(5);
+                    let messageIndex = 0;
+                    const sendProgress = setInterval(() => {
+                        if (messageIndex < progressMessages.length) {
+                            ws.send(progressMessages[messageIndex]);
+                            messageIndex++;
+                        }
+                        else {
+                            clearInterval(sendProgress);
+                            // Send completed message with mock video data
+                            const mockVideoData = Buffer.from("mock video content for testing");
+                            ws.send(JSON.stringify({
+                                status: "completed",
+                                progress: 1.0,
+                                video_data: Array.from(mockVideoData),
+                                error: null,
+                            }));
+                        }
+                    }, 10);
+                });
+            }
+        });
+        // Start the server on a random port
+        await new Promise((resolve) => {
+            mockHttpServer.listen(0, () => {
+                const address = mockHttpServer.address();
+                serverPort = address.port;
+                resolve();
+            });
+        });
+    });
+    (0, vitest_1.afterEach)(async () => {
+        mockWsServer.close();
+        await new Promise((resolve) => {
+            mockHttpServer.close(() => resolve());
+        });
+    });
+    (0, vitest_1.it)("should parse ISO 8601 timestamps correctly", () => {
+        const startTime = "2024-01-15T10:00:00Z";
+        const endTime = "2024-01-15T10:30:00Z";
+        const startDate = new Date(startTime);
+        const endDate = new Date(endTime);
+        (0, vitest_1.expect)(startDate.getTime()).toBeLessThan(endDate.getTime());
+        (0, vitest_1.expect)(endDate.getTime() - startDate.getTime()).toBe(30 * 60 * 1000); // 30 minutes
+    });
+    (0, vitest_1.it)("should extract unique frame IDs from search results", () => {
+        const searchResults = createMockSearchResponse([100, 101, 100, 102, 101, 103]);
+        const frameIds = [];
+        const seenIds = new Set();
+        for (const result of searchResults.data) {
+            if (result.type === "OCR" && result.content?.frame_id) {
+                const frameId = result.content.frame_id;
+                if (!seenIds.has(frameId)) {
+                    seenIds.add(frameId);
+                    frameIds.push(frameId);
+                }
+            }
+        }
+        (0, vitest_1.expect)(frameIds).toEqual([100, 101, 102, 103]);
+        (0, vitest_1.expect)(frameIds.length).toBe(4);
+    });
+    (0, vitest_1.it)("should handle empty search results", () => {
+        const emptyResults = { data: [] };
+        const frameIds = [];
+        for (const result of emptyResults.data) {
+            if (result.type === "OCR" && result.content?.frame_id) {
+                frameIds.push(result.content.frame_id);
+            }
+        }
+        (0, vitest_1.expect)(frameIds.length).toBe(0);
+    });
+    (0, vitest_1.it)("should build correct WebSocket URL with frame IDs", () => {
+        const frameIds = [100, 101, 102];
+        const fps = 1.0;
+        const port = 3030;
+        const wsUrl = `ws://localhost:${port}/frames/export?frame_ids=${frameIds.join(",")}&fps=${fps}`;
+        (0, vitest_1.expect)(wsUrl).toBe("ws://localhost:3030/frames/export?frame_ids=100,101,102&fps=1");
+    });
+    (0, vitest_1.it)("should connect to mock WebSocket server and receive messages", async () => {
+        const wsUrl = `ws://localhost:${serverPort}/frames/export?frame_ids=100,101,102&fps=1`;
+        const result = await new Promise((resolve) => {
+            const ws = new ws_1.default(wsUrl);
+            let lastMessage;
+            ws.on("error", (error) => {
+                resolve({ success: false, error: error.message });
+            });
+            ws.on("message", (data) => {
+                try {
+                    lastMessage = JSON.parse(data.toString());
+                    if (lastMessage.status === "completed") {
+                        ws.close();
+                        resolve({ success: true, data: lastMessage });
+                    }
+                }
+                catch (e) {
+                    // Ignore parse errors
+                }
+            });
+            ws.on("close", () => {
+                if (!lastMessage || lastMessage.status !== "completed") {
+                    resolve({ success: false, error: "Connection closed before completion" });
+                }
+            });
+            // Timeout after 5 seconds
+            setTimeout(() => {
+                ws.close();
+                resolve({ success: false, error: "Timeout" });
+            }, 5000);
+        });
+        (0, vitest_1.expect)(result.success).toBe(true);
+        (0, vitest_1.expect)(result.data).toBeDefined();
+        (0, vitest_1.expect)(result.data.status).toBe("completed");
+        (0, vitest_1.expect)(result.data.video_data).toBeDefined();
+        (0, vitest_1.expect)(Array.isArray(result.data.video_data)).toBe(true);
+    });
+    (0, vitest_1.it)("should save video data to temp file", () => {
+        const mockVideoData = Buffer.from("mock video content");
+        const tempDir = os.tmpdir();
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const filename = `screenpipe_export_test_${timestamp}.mp4`;
+        const filePath = path.join(tempDir, filename);
+        fs.writeFileSync(filePath, mockVideoData);
+        (0, vitest_1.expect)(fs.existsSync(filePath)).toBe(true);
+        const readData = fs.readFileSync(filePath);
+        (0, vitest_1.expect)(readData.toString()).toBe("mock video content");
+        // Cleanup
+        fs.unlinkSync(filePath);
+    });
+    (0, vitest_1.it)("should sort frame IDs in ascending order", () => {
+        const unsortedIds = [103, 100, 105, 101, 102];
+        const sortedIds = [...unsortedIds].sort((a, b) => a - b);
+        (0, vitest_1.expect)(sortedIds).toEqual([100, 101, 102, 103, 105]);
+    });
+    (0, vitest_1.it)("should handle search API errors gracefully", async () => {
+        // Create a server that returns an error
+        const errorServer = http.createServer((req, res) => {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Internal server error" }));
+        });
+        await new Promise((resolve) => {
+            errorServer.listen(0, () => resolve());
+        });
+        const address = errorServer.address();
+        const port = address.port;
+        try {
+            const response = await fetch(`http://localhost:${port}/search?start_time=2024-01-01T00:00:00Z&end_time=2024-01-01T01:00:00Z`);
+            (0, vitest_1.expect)(response.ok).toBe(false);
+            (0, vitest_1.expect)(response.status).toBe(500);
+        }
+        finally {
+            await new Promise((resolve) => {
+                errorServer.close(() => resolve());
+            });
+        }
+    });
+    (0, vitest_1.it)("should handle WebSocket connection errors", async () => {
+        const ws = new ws_1.default("ws://localhost:59999/invalid"); // Port that's not listening
+        const result = await new Promise((resolve) => {
+            ws.on("open", () => {
+                resolve({ connected: true });
+            });
+            ws.on("error", (error) => {
+                resolve({ connected: false, error: error.message });
+            });
+            setTimeout(() => {
+                resolve({ connected: false, error: "Timeout" });
+            }, 2000);
+        });
+        (0, vitest_1.expect)(result.connected).toBe(false);
+    });
+    (0, vitest_1.it)("should validate time range parameters", () => {
+        const startTime = "2024-01-15T10:30:00Z";
+        const endTime = "2024-01-15T10:00:00Z"; // End before start
+        const startDate = new Date(startTime);
+        const endDate = new Date(endTime);
+        // This should be invalid (end before start)
+        (0, vitest_1.expect)(endDate.getTime()).toBeLessThan(startDate.getTime());
+    });
+    (0, vitest_1.it)("should handle audio-only results (no frame IDs)", () => {
+        const audioOnlyResults = {
+            data: [
+                {
+                    type: "Audio",
+                    content: {
+                        transcription: "Hello world",
+                        timestamp: "2024-01-15T10:00:00Z",
+                        device_name: "Microphone",
+                    },
+                },
+                {
+                    type: "Audio",
+                    content: {
+                        transcription: "How are you",
+                        timestamp: "2024-01-15T10:01:00Z",
+                        device_name: "Microphone",
+                    },
+                },
+            ],
+        };
+        const frameIds = [];
+        for (const result of audioOnlyResults.data) {
+            if (result.type === "OCR" && result.content?.frame_id) {
+                frameIds.push(result.content.frame_id);
+            }
+        }
+        (0, vitest_1.expect)(frameIds.length).toBe(0);
+    });
+});
+(0, vitest_1.describe)("export-video tool schema validation", () => {
+    (0, vitest_1.it)("should have correct input schema", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                start_time: {
+                    type: "string",
+                    format: "date-time",
+                },
+                end_time: {
+                    type: "string",
+                    format: "date-time",
+                },
+                fps: {
+                    type: "number",
+                    default: 1.0,
+                },
+            },
+            required: ["start_time", "end_time"],
+        };
+        (0, vitest_1.expect)(schema.required).toContain("start_time");
+        (0, vitest_1.expect)(schema.required).toContain("end_time");
+        (0, vitest_1.expect)(schema.required).not.toContain("fps"); // fps is optional
+        (0, vitest_1.expect)(schema.properties.fps.default).toBe(1.0);
+    });
+});

package/dist/http-server.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * HTTP Server for Screenpipe MCP
+ *
+ * This allows web apps to call MCP tools over HTTP instead of stdio.
+ * Run with: npx ts-node src/http-server.ts --port 3031
+ */
+export {};

package/dist/http-server.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * HTTP Server for Screenpipe MCP
+ *
+ * This allows web apps to call MCP tools over HTTP instead of stdio.
+ * Run with: npx ts-node src/http-server.ts --port 3031
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("http");
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+// Parse command line arguments
+const args = process.argv.slice(2);
+let mcpPort = 3031;
+let screenpipePort = 3030;
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--port" && args[i + 1]) {
+        mcpPort = parseInt(args[i + 1], 10);
+    }
+    if (args[i] === "--screenpipe-port" && args[i + 1]) {
+        screenpipePort = parseInt(args[i + 1], 10);
+    }
+}
+const SCREENPIPE_API = `http://localhost:${screenpipePort}`;
+// Tool definitions
+const TOOLS = [
+    {
+        name: "search_content",
+        description: "Search screenpipe's recorded content: screen text (OCR), audio transcriptions, and UI elements. " +
+            "Returns timestamped results with app context. " +
+            "Call with no parameters to get recent activity.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                q: {
+                    type: "string",
+                    description: "Search query. Optional - omit to return all recent content.",
+                },
+                content_type: {
+                    type: "string",
+                    enum: ["all", "ocr", "audio", "ui"],
+                    description: "Content type filter. Default: 'all'",
+                },
+                limit: {
+                    type: "integer",
+                    description: "Max results. Default: 10",
+                },
+                offset: {
+                    type: "integer",
+                    description: "Skip N results for pagination. Default: 0",
+                },
+                start_time: {
+                    type: "string",
+                    description: "ISO 8601 UTC start time (e.g., 2024-01-15T10:00:00Z)",
+                },
+                end_time: {
+                    type: "string",
+                    description: "ISO 8601 UTC end time (e.g., 2024-01-15T18:00:00Z)",
+                },
+                app_name: {
+                    type: "string",
+                    description: "Filter by app (e.g., 'Google Chrome', 'Slack', 'zoom.us')",
+                },
+                window_name: {
+                    type: "string",
+                    description: "Filter by window title",
+                },
+            },
+        },
+    },
+];
+// Helper function to make HTTP requests
+async function fetchAPI(endpoint, options = {}) {
+    const url = `${SCREENPIPE_API}${endpoint}`;
+    return fetch(url, {
+        ...options,
+        headers: {
+            "Content-Type": "application/json",
+            ...options.headers,
+        },
+    });
+}
+// Create MCP server
+const server = new index_js_1.Server({
+    name: "screenpipe-http",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List tools handler
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+// Call tool handler
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    if (!args) {
+        throw new Error("Missing arguments");
+    }
+    if (name === "search_content") {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(args)) {
+            if (value !== null && value !== undefined) {
+                params.append(key, String(value));
+            }
+        }
+        const response = await fetchAPI(`/search?${params.toString()}`);
+        if (!response.ok) {
+            throw new Error(`HTTP error: ${response.status}`);
+        }
+        const data = await response.json();
+        const results = data.data || [];
+        const pagination = data.pagination || {};
+        if (results.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No results found. Try: broader search terms, different content_type, or wider time range.",
+                    },
+                ],
+            };
+        }
+        const formattedResults = [];
+        for (const result of results) {
+            const content = result.content;
+            if (!content)
+                continue;
+            if (result.type === "OCR") {
+                formattedResults.push(`[OCR] ${content.app_name || "?"} | ${content.window_name || "?"}\n` +
+                    `${content.timestamp || ""}\n` +
+                    `${content.text || ""}`);
+            }
+            else if (result.type === "Audio") {
+                formattedResults.push(`[Audio] ${content.device_name || "?"}\n` +
+                    `${content.timestamp || ""}\n` +
+                    `${content.transcription || ""}`);
+            }
+            else if (result.type === "UI") {
+                formattedResults.push(`[UI] ${content.app_name || "?"} | ${content.window_name || "?"}\n` +
+                    `${content.timestamp || ""}\n` +
+                    `${content.text || ""}`);
+            }
+        }
+        const header = `Results: ${results.length}/${pagination.total || "?"}` +
+            (pagination.total > results.length ? ` (use offset=${(pagination.offset || 0) + results.length} for more)` : "");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: header + "\n\n" + formattedResults.join("\n---\n"),
+                },
+            ],
+        };
+    }
+    throw new Error(`Unknown tool: ${name}`);
+});
+// Create HTTP server with MCP transport
+const transports = new Map();
+const httpServer = (0, http_1.createServer)(async (req, res) => {
+    // CORS headers
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, mcp-session-id");
+    if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    // Health check
+    if (req.url === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok" }));
+        return;
+    }
+    // MCP endpoint
+    if (req.url === "/mcp" || req.url?.startsWith("/mcp?")) {
+        const sessionId = req.headers["mcp-session-id"];
+        let transport = sessionId ? transports.get(sessionId) : undefined;
+        if (!transport) {
+            transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                sessionIdGenerator: () => crypto.randomUUID(),
+            });
+            await server.connect(transport);
+            if (transport.sessionId) {
+                transports.set(transport.sessionId, transport);
+            }
+        }
+        await transport.handleRequest(req, res);
+        return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+});
+httpServer.listen(mcpPort, () => {
+    console.log(`Screenpipe MCP HTTP server running on http://localhost:${mcpPort}`);
+    console.log(`MCP endpoint: http://localhost:${mcpPort}/mcp`);
+    console.log(`Health check: http://localhost:${mcpPort}/health`);
+});