screenpipe-mcp 0.18.6 → 0.18.7

package/dist/http-server.js

@@ -284,11 +284,14 @@ function buildHttpServer(config) {
                 const server = createMcpServer(fetchAPI);
                 const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
                     sessionIdGenerator: () => crypto.randomUUID(),
+                    onsessioninitialized: (newSessionId) => {
+                        sessions.set(newSessionId, { server, transport });
+                    },
+                    onsessionclosed: (closedSessionId) => {
+                        sessions.delete(closedSessionId);
+                    },
                 });
                 await server.connect(transport);
-                if (transport.sessionId) {
-                    sessions.set(transport.sessionId, { server, transport });
-                }
                 session = { server, transport };
             }
             await session.transport.handleRequest(req, res);

package/dist/http-server.test.js

@@ -147,3 +147,74 @@ const http_server_1 = require("./http-server");
         (0, vitest_1.expect)((0, http_server_1.isAuthorized)(lan("Bearer SECRET"), "secret")).toBe(false);
     });
 });
+(0, vitest_1.describe)("buildHttpServer", () => {
+    (0, vitest_1.it)("persists initialized sessions so tools/list works on the next request", async () => {
+        const server = (0, http_server_1.buildHttpServer)({
+            mcpPort: 0,
+            screenpipePort: 3030,
+            host: "127.0.0.1",
+            apiKey: "secret",
+        });
+        await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+        const address = server.address();
+        if (!address || typeof address === "string") {
+            throw new Error("expected server.address() to return a bound port");
+        }
+        const baseUrl = `http://127.0.0.1:${address.port}`;
+        try {
+            const initResponse = await fetch(`${baseUrl}/mcp`, {
+                method: "POST",
+                headers: {
+                    authorization: "Bearer secret",
+                    "content-type": "application/json",
+                    accept: "application/json, text/event-stream",
+                },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: 1,
+                    method: "initialize",
+                    params: {
+                        protocolVersion: "2024-11-05",
+                        capabilities: {},
+                        clientInfo: { name: "vitest", version: "1.0.0" },
+                    },
+                }),
+            });
+            (0, vitest_1.expect)(initResponse.status).toBe(200);
+            const sessionId = initResponse.headers.get("mcp-session-id");
+            (0, vitest_1.expect)(sessionId).toBeTruthy();
+            await initResponse.text();
+            const healthResponse = await fetch(`${baseUrl}/health`);
+            (0, vitest_1.expect)(healthResponse.status).toBe(200);
+            (0, vitest_1.expect)(await healthResponse.json()).toEqual({ status: "ok", sessions: 1 });
+            const toolsResponse = await fetch(`${baseUrl}/mcp`, {
+                method: "POST",
+                headers: {
+                    authorization: "Bearer secret",
+                    "content-type": "application/json",
+                    accept: "application/json, text/event-stream",
+                    "mcp-session-id": sessionId,
+                    "mcp-protocol-version": "2024-11-05",
+                },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: 2,
+                    method: "tools/list",
+                    params: {},
+                }),
+            });
+            (0, vitest_1.expect)(toolsResponse.status).toBe(200);
+            (0, vitest_1.expect)(await toolsResponse.text()).toContain('"name":"search_content"');
+        }
+        finally {
+            await new Promise((resolve, reject) => {
+                server.close((err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screenpipe-mcp",
-  "version": "0.18.6",
+  "version": "0.18.7",
   "description": "MCP server for screenpipe - search your screen recordings and audio transcriptions",
   "main": "dist/index.js",
   "bin": {

package/src/http-server.test.ts

@@ -4,6 +4,7 @@
 
 import { describe, it, expect } from "vitest";
 import {
+  buildHttpServer,
   CliError,
   isAuthorized,
   isLoopbackRequest,
@@ -178,3 +179,80 @@ describe("isAuthorized", () => {
     expect(isAuthorized(lan("Bearer SECRET"), "secret")).toBe(false);
   });
 });
+
+describe("buildHttpServer", () => {
+  it("persists initialized sessions so tools/list works on the next request", async () => {
+    const server = buildHttpServer({
+      mcpPort: 0,
+      screenpipePort: 3030,
+      host: "127.0.0.1",
+      apiKey: "secret",
+    });
+
+    await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+
+    const address = server.address();
+    if (!address || typeof address === "string") {
+      throw new Error("expected server.address() to return a bound port");
+    }
+
+    const baseUrl = `http://127.0.0.1:${address.port}`;
+
+    try {
+      const initResponse = await fetch(`${baseUrl}/mcp`, {
+        method: "POST",
+        headers: {
+          authorization: "Bearer secret",
+          "content-type": "application/json",
+          accept: "application/json, text/event-stream",
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "initialize",
+          params: {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "vitest", version: "1.0.0" },
+          },
+        }),
+      });
+
+      expect(initResponse.status).toBe(200);
+      const sessionId = initResponse.headers.get("mcp-session-id");
+      expect(sessionId).toBeTruthy();
+      await initResponse.text();
+
+      const healthResponse = await fetch(`${baseUrl}/health`);
+      expect(healthResponse.status).toBe(200);
+      expect(await healthResponse.json()).toEqual({ status: "ok", sessions: 1 });
+
+      const toolsResponse = await fetch(`${baseUrl}/mcp`, {
+        method: "POST",
+        headers: {
+          authorization: "Bearer secret",
+          "content-type": "application/json",
+          accept: "application/json, text/event-stream",
+          "mcp-session-id": sessionId!,
+          "mcp-protocol-version": "2024-11-05",
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 2,
+          method: "tools/list",
+          params: {},
+        }),
+      });
+
+      expect(toolsResponse.status).toBe(200);
+      expect(await toolsResponse.text()).toContain('"name":"search_content"');
+    } finally {
+      await new Promise<void>((resolve, reject) => {
+        server.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    }
+  });
+});

package/src/http-server.ts

@@ -337,13 +337,15 @@ export function buildHttpServer(config: CliConfig) {
         const server = createMcpServer(fetchAPI);
         const transport = new StreamableHTTPServerTransport({
           sessionIdGenerator: () => crypto.randomUUID(),
+          onsessioninitialized: (newSessionId) => {
+            sessions.set(newSessionId, { server, transport });
+          },
+          onsessionclosed: (closedSessionId) => {
+            sessions.delete(closedSessionId);
+          },
         });
 
         await server.connect(transport);
-
-        if (transport.sessionId) {
-          sessions.set(transport.sessionId, { server, transport });
-        }
         session = { server, transport };
       }