desearch-mcp-server 0.0.1 → 0.1.3

package/build/http.js

@@ -0,0 +1,324 @@
+import { createServer } from "node:http";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { createDesearchMcpServer, SERVER_NAME, SERVER_VERSION } from "./server.js";
+const CORS_HEADERS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Accept, Authorization, x-api-key, Mcp-Session-Id, Mcp-Protocol-Version, Last-Event-ID",
+    "Access-Control-Expose-Headers": "Mcp-Session-Id",
+    "Access-Control-Max-Age": "86400",
+};
+const HOP_BY_HOP = new Set([
+    "connection",
+    "keep-alive",
+    "transfer-encoding",
+    "upgrade",
+    "host",
+    "content-length",
+]);
+/**
+ * Desearch API key from the remote client.
+ * Prefer `Authorization: Bearer <key>` (what MCP clients send). `x-api-key` is
+ * accepted as well. A bare `Authorization: <key>` value is accepted so the same
+ * string used as `DESEARCH_API_KEY` for stdio can be sent without a scheme.
+ * Query strings are ignored so keys do not land in access logs.
+ */
+/**
+ * Copy a request onto another path. Used by the Vercel functions, which see
+ * the rewritten URL (`/api/mcp`) rather than the public path (`/mcp`).
+ */
+export function requestWithPathname(request, pathname) {
+    const url = new URL(request.url);
+    url.pathname = pathname;
+    const method = request.method;
+    const init = {
+        method,
+        headers: request.headers,
+    };
+    if (method !== "GET" && method !== "HEAD") {
+        init.body = request.body;
+        init.duplex = "half";
+    }
+    return new Request(url, init);
+}
+export function extractDesearchApiKey(request) {
+    const authorization = request.headers.get("authorization")?.trim();
+    if (authorization) {
+        const bearer = /^Bearer\s+(\S+)$/i.exec(authorization);
+        if (bearer?.[1]) {
+            return bearer[1];
+        }
+        if (!/^Bearer\b/i.test(authorization) && !/\s/.test(authorization)) {
+            return authorization;
+        }
+    }
+    const headerKey = request.headers.get("x-api-key")?.trim();
+    if (headerKey) {
+        return headerKey;
+    }
+    return undefined;
+}
+function normalizePath(pathname) {
+    if (pathname.length > 1 && pathname.endsWith("/")) {
+        return pathname.slice(0, -1);
+    }
+    return pathname;
+}
+function isMcpPath(pathname) {
+    return pathname === "/mcp" || pathname === "/api/mcp";
+}
+function isHealthPath(pathname) {
+    // `/api/health` is the Vercel function path. The public rewrite of `/health`
+    // delivers that pathname when the function wrapper does not remap it, and
+    // `isMcpPath` already accepts both `/mcp` and `/api/mcp` for the same reason.
+    return pathname === "/" || pathname === "/health" || pathname === "/api/health";
+}
+function withCors(response) {
+    const headers = new Headers(response.headers);
+    for (const [key, value] of Object.entries(CORS_HEADERS)) {
+        headers.set(key, value);
+    }
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+function jsonRpcError(status, code, message, extra) {
+    const headers = new Headers({ "Content-Type": "application/json", ...extra });
+    return new Response(JSON.stringify({
+        jsonrpc: "2.0",
+        error: { code, message },
+        id: null,
+    }), { status, headers });
+}
+function healthResponse() {
+    return new Response(JSON.stringify({
+        ok: true,
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+        transport: "streamable-http",
+        endpoint: "/mcp",
+        auth: "initialize and tools/list are public. tools/call requires Authorization: Bearer <DESEARCH_API_KEY> or x-api-key.",
+    }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+function unauthorized() {
+    // No OAuth challenge. Desearch auth is a per-user API key, and a
+    // WWW-Authenticate discovery hint makes some MCP clients start an OAuth flow.
+    return jsonRpcError(401, -32001, "Unauthorized. Send your Desearch API key in the Authorization: Bearer <key> header or the x-api-key header.");
+}
+/**
+ * Methods a marketplace scanner can call with no Desearch API key.
+ * Anything else, including tools/call, stays on the 401 gate so a missing
+ * key never reaches the Desearch API.
+ */
+const KEYLESS_METHODS = new Set([
+    "initialize",
+    "notifications/initialized",
+    "ping",
+    "tools/list",
+    "prompts/list",
+    "resources/list",
+    "resources/templates/list",
+]);
+function isKeylessDiscovery(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return false;
+    }
+    const messages = Array.isArray(parsed) ? parsed : [parsed];
+    return (messages.length > 0 &&
+        messages.every((message) => {
+            if (typeof message !== "object" || message === null) {
+                return false;
+            }
+            const method = message.method;
+            return typeof method === "string" && KEYLESS_METHODS.has(method);
+        }));
+}
+function copyRequestHeaders(headers) {
+    const copied = new Headers();
+    headers.forEach((value, key) => {
+        if (key.toLowerCase() === "content-length" || key.toLowerCase() === "host") {
+            return;
+        }
+        try {
+            copied.append(key, value);
+        }
+        catch {
+            // The Fetch constructor rejects forbidden request headers such as host.
+        }
+    });
+    return copied;
+}
+function requestWithJsonBody(request, body) {
+    const init = { method: "POST", headers: request.headers, body };
+    try {
+        return new Request(request.url, init);
+    }
+    catch {
+        return new Request(request.url, { ...init, headers: copyRequestHeaders(request.headers) });
+    }
+}
+/**
+ * Stateless Streamable HTTP handler.
+ * Each POST builds a fresh MCP server tied to that request's API key.
+ * JSON responses (not a long-lived SSE session) so the same handler runs
+ * in a local Node process and in a Vercel function.
+ * GET and DELETE return 405: this server does not push messages or store sessions.
+ */
+export async function handleMcpHttpRequest(request) {
+    if (request.method === "OPTIONS") {
+        return withCors(new Response(null, { status: 204 }));
+    }
+    const pathname = normalizePath(new URL(request.url).pathname);
+    if (isHealthPath(pathname)) {
+        if (request.method === "GET") {
+            return withCors(healthResponse());
+        }
+        return withCors(jsonRpcError(405, -32000, "Method not allowed.", { Allow: "GET" }));
+    }
+    if (!isMcpPath(pathname)) {
+        return withCors(new Response(JSON.stringify({ error: "Not found" }), {
+            status: 404,
+            headers: { "Content-Type": "application/json" },
+        }));
+    }
+    if (request.method === "GET" || request.method === "DELETE") {
+        if (!extractDesearchApiKey(request)) {
+            return withCors(unauthorized());
+        }
+        return withCors(jsonRpcError(405, -32000, "Method not allowed. This server is stateless; use POST.", { Allow: "POST" }));
+    }
+    if (request.method !== "POST") {
+        return withCors(jsonRpcError(405, -32000, "Method not allowed.", { Allow: "POST" }));
+    }
+    let apiKey = extractDesearchApiKey(request);
+    if (!apiKey) {
+        const raw = await request.text();
+        if (!isKeylessDiscovery(raw)) {
+            return withCors(unauthorized());
+        }
+        request = requestWithJsonBody(request, raw);
+        apiKey = "";
+    }
+    const server = createDesearchMcpServer(apiKey);
+    const transport = new WebStandardStreamableHTTPServerTransport({
+        enableJsonResponse: true,
+    });
+    transport.onerror = (error) => {
+        console.error(`MCP HTTP error: ${error.message}`);
+    };
+    try {
+        await server.connect(transport);
+        const response = await transport.handleRequest(request);
+        return withCors(response);
+    }
+    catch (error) {
+        console.error(`MCP HTTP handler error: ${error instanceof Error ? error.message : String(error)}`);
+        return withCors(jsonRpcError(500, -32603, "Internal server error"));
+    }
+    finally {
+        await transport.close().catch(() => undefined);
+        await server.close().catch(() => undefined);
+    }
+}
+function readRawBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => {
+            chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+        });
+        // TS 5.7+ DOM BodyInit accepts Uint8Array<ArrayBuffer> and rejects
+        // Uint8Array<ArrayBufferLike> (Node Buffer, whose buffer may be a
+        // SharedArrayBuffer). Copy into a plain ArrayBuffer.
+        req.on("end", () => resolve(new Uint8Array(Buffer.concat(chunks))));
+        req.on("error", reject);
+    });
+}
+async function toWebRequest(req) {
+    const host = req.headers.host ?? "localhost";
+    const url = `http://${host}${req.url ?? "/"}`;
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (value === undefined || HOP_BY_HOP.has(key.toLowerCase())) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                headers.append(key, entry);
+            }
+        }
+        else {
+            headers.set(key, value);
+        }
+    }
+    const method = req.method ?? "GET";
+    const hasBody = method !== "GET" && method !== "HEAD";
+    const body = hasBody ? await readRawBody(req) : undefined;
+    return new Request(url, {
+        method,
+        headers,
+        body: body && body.byteLength > 0 ? body : undefined,
+    });
+}
+async function writeWebResponse(res, response) {
+    const body = Buffer.from(await response.arrayBuffer());
+    const headers = new Headers(response.headers);
+    headers.set("content-length", String(body.byteLength));
+    const outgoing = {};
+    headers.forEach((value, key) => {
+        outgoing[key] = value;
+    });
+    res.writeHead(response.status, outgoing);
+    res.end(body);
+}
+export function startHttpServer(options = {}) {
+    const host = options.host ?? "0.0.0.0";
+    const port = options.port ?? 3000;
+    const nodeServer = createServer(async (req, res) => {
+        try {
+            const request = await toWebRequest(req);
+            const response = await handleMcpHttpRequest(request);
+            await writeWebResponse(res, response);
+        }
+        catch (error) {
+            console.error(`HTTP server error: ${error instanceof Error ? error.message : String(error)}`);
+            if (!res.headersSent) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({
+                    jsonrpc: "2.0",
+                    error: { code: -32603, message: "Internal server error" },
+                    id: null,
+                }));
+            }
+            else {
+                res.end();
+            }
+        }
+    });
+    return new Promise((resolve, reject) => {
+        nodeServer.once("error", reject);
+        nodeServer.listen(port, host, () => {
+            const address = nodeServer.address();
+            const boundPort = typeof address === "object" && address ? address.port : port;
+            console.error(`Desearch MCP listening on ${host}:${boundPort} (endpoint /mcp)`);
+            resolve({
+                host,
+                port: boundPort,
+                close: () => new Promise((closeResolve, closeReject) => {
+                    // Client transports abort the optional GET stream and can leave
+                    // a socket that close() would otherwise hold until timeout.
+                    nodeServer.closeAllConnections();
+                    nodeServer.close((error) => (error ? closeReject(error) : closeResolve()));
+                }),
+            });
+        });
+    });
+}

package/build/index.js

@@ -1,124 +1,30 @@
 #!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import Desearch from "desearch-js";
-const server = new McpServer({
-    name: "Desearch",
-    version: "0.0.1",
-});
-const DESEARCH_API_KEY = process.env.DESEARCH_API_KEY;
-if (!DESEARCH_API_KEY) {
-    throw new Error("DESEARCH_API_KEY environment variable is required");
+import { startHttpServer } from "./http.js";
+import { createDesearchMcpServer } from "./server.js";
+function wantsHttp() {
+    return process.argv.includes("--http") || process.env.MCP_TRANSPORT === "http";
 }
-const desearch = new Desearch(DESEARCH_API_KEY);
-server.tool("ai-search", "Real-time AI search and analysis on web using Desearch AI", {
-    prompt: z.string().describe("Question, example: 'What is the latest news on AI?'"),
-    tools: z
-        .array(z.enum([
-        "Twitter Search",
-        "Web Search",
-        "ArXiv Search",
-        "Wikipedia Search",
-        "Youtube Search",
-        "Hacker News Search",
-        "Reddit Search",
-    ]))
-        .optional()
-        .default(["Twitter Search", "Web Search"])
-        .describe("Tools to use for the search, example: ['Web Search', 'Twitter Search']"),
-    date_filter: z
-        .enum([
-        "PAST_24_HOURS",
-        "PAST_2_DAYS",
-        "PAST_WEEK",
-        "PAST_2_WEEKS",
-        "PAST_MONTH",
-        "PAST_2_MONTHS",
-        "PAST_YEAR",
-        "PAST_2_YEARS",
-    ])
-        .optional()
-        .describe("Time range for the search, example: 'PAST_WEEK'"),
-    model: z
-        .enum(["NOVA", "ORBIT"])
-        .default("NOVA")
-        .describe("Model to use for the search, example: 'NOVA', Nova is 10s model, Orbit is 30s model"),
-}, async ({ prompt, tools, date_filter, model }) => {
-    try {
-        const aiResult = await desearch.AISearch({
-            prompt,
-            tools,
-            date_filter,
-            model,
-            streaming: false,
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(aiResult, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `X Search error: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-});
-server.tool("x-search", "Search the X (Twitter) using Desearch AI - performs real-time tweet search on X.", {
-    query: z
-        .string()
-        .describe("Twitter advanced search query, example: 'from:elonmusk since:2023-01-01 min_replies:10'"),
-    count: z
-        .number()
-        .optional()
-        .default(20)
-        .describe("Number of search results to return (default: 20), max is 100"),
-}, async ({ query, count }) => {
-    try {
-        const twitterResult = await desearch.twitterSearch({
-            query,
-            sort: "Top",
-            count,
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(twitterResult, null, 2),
-                },
-            ],
-        };
+async function main() {
+    if (wantsHttp()) {
+        const port = Number(process.env.PORT ?? "3000");
+        if (!Number.isInteger(port) || port < 0 || port > 65535) {
+            throw new Error("PORT must be an integer between 0 and 65535");
+        }
+        const host = process.env.HOST ?? "0.0.0.0";
+        await startHttpServer({ port, host });
+        return;
     }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `X Search error: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
+    const apiKey = process.env.DESEARCH_API_KEY;
+    if (!apiKey) {
+        throw new Error("DESEARCH_API_KEY environment variable is required");
     }
+    const server = createDesearchMcpServer(apiKey);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Desearch server is running...");
+}
+main().catch((error) => {
+    console.error(`Server error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
 });
-(async () => {
-    try {
-        // Start receiving messages on stdin and sending messages on stdout
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
-    }
-    catch (error) {
-        console.log(`Server error: ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
-    }
-})();

package/build/server.d.ts

@@ -0,0 +1,103 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const SERVER_NAME = "Desearch";
+export declare const SERVER_VERSION = "0.1.3";
+interface XSearchPayload {
+    query: string;
+    sort?: "Top" | "Latest";
+    count?: number;
+    user?: string;
+    start_date?: string;
+    end_date?: string;
+    lang?: string;
+    verified?: boolean;
+    blue_verified?: boolean;
+    is_quote?: boolean;
+    is_video?: boolean;
+    is_image?: boolean;
+    min_retweets?: number | string;
+    min_replies?: number | string;
+    min_likes?: number | string;
+}
+interface PageContentPayload {
+    url: string;
+    format?: "html" | "text";
+    js?: boolean;
+    wait?: number;
+}
+interface DesearchClient {
+    aiSearch(payload: Record<string, unknown>): Promise<unknown>;
+    xSearch(payload: XSearchPayload): Promise<unknown>;
+    webSearch(payload: {
+        query: string;
+        start?: number;
+    }): Promise<unknown>;
+    aiWebLinksSearch(payload: {
+        prompt: string;
+        tools: string[];
+        count?: number;
+    }): Promise<unknown>;
+    aiXLinksSearch(payload: {
+        prompt: string;
+        count?: number;
+    }): Promise<unknown>;
+    xPostsByUrls(payload: {
+        urls: string[];
+    }): Promise<unknown>;
+    xPostById(payload: {
+        id: string;
+    }): Promise<unknown>;
+    xPostsByUser(payload: {
+        user: string;
+        query?: string;
+        count?: number;
+    }): Promise<unknown>;
+    xPostRetweeters(payload: {
+        id: string;
+        cursor?: string;
+    }): Promise<unknown>;
+    xUserPosts(payload: {
+        username: string;
+        cursor?: string;
+    }): Promise<unknown>;
+    xUserReplies(payload: {
+        user: string;
+        count?: number;
+        query?: string;
+    }): Promise<unknown>;
+    xPostReplies(payload: {
+        post_id: string;
+        count?: number;
+        query?: string;
+    }): Promise<unknown>;
+    xTrends(payload: {
+        woeid: number;
+        count?: number;
+    }): Promise<unknown>;
+    extract(payload: PageContentPayload): Promise<unknown>;
+    webCrawl(payload: PageContentPayload): Promise<unknown>;
+}
+/**
+ * Payload note when a link search body has no link list.
+ * Does not name web vs AI search, and does not say the query had "results".
+ * A missing list (the cost-only API bug) and an empty list are the same note:
+ * this response body does not contain links.
+ */
+export declare const NO_LINKS_MESSAGE = "no links in response";
+/**
+ * Pass a link payload through when it contains at least one link.
+ * A cost-only body (billing fields, no link list) and an empty link list
+ * both get `message: "no links in response"` plus the original fields,
+ * including billing. The note does not claim the search returned results
+ * and does not name which search tool produced the body.
+ */
+export declare function presentSearchBody(value: unknown): unknown;
+/**
+ * One MCP server bound to a single Desearch API key.
+ * Stdio uses the process env key. Remote HTTP builds a new server per request
+ * so each caller spends their own key.
+ * `client` is a test seam. Production callers omit it and the server builds
+ * a desearch-js client from `apiKey`.
+ */
+export declare function createDesearchMcpServer(apiKey: string, client?: DesearchClient): McpServer;
+export {};
+//# sourceMappingURL=server.d.ts.map

package/build/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../server.ts"],"names":[],"mappings":"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"}