orbitx 0.0.1 → 0.0.2

package/src/tools/utils/get-current-time.ts

@@ -0,0 +1,45 @@
+import MCPTool from "../../core/mcp";
+
+export const GetCurrentTimeTool = new MCPTool({
+    name: "get-current-time",
+    description: "Returns current time (24h) and today's date in Gregorian, Persian, and Islamic calendars.",
+    inputs: [],
+    execute: async (_: string, __: Record<string, any>): Promise<any> => {
+        const now = new Date();
+        const time = now.toLocaleTimeString("en-US", {
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false
+        });
+
+        const gregorian = now.toLocaleDateString("en-US", {
+            weekday: "long",
+            year: "numeric",
+            month: "long",
+            day: "numeric"
+        });
+
+        const persian = now.toLocaleDateString("fa-IR-u-ca-persian", {
+            weekday: "long",
+            year: "numeric",
+            month: "long",
+            day: "numeric"
+        });
+
+        const hijri = now.toLocaleDateString("ar-SA-u-ca-islamic", {
+            weekday: "long",
+            year: "numeric",
+            month: "long",
+            day: "numeric"
+        });
+
+        return {
+            time,
+            gregorian,
+            persian,
+            hijri
+        };
+    },
+});
+
+export default GetCurrentTimeTool;

package/src/tools/utils/index.ts

@@ -0,0 +1 @@
+export { GetCurrentTimeTool } from "./get-current-time"

package/src/tools/www/fetch.ts

@@ -0,0 +1,161 @@
+import MCPTool from "../../core/mcp";
+
+export const FetchTool = new MCPTool({
+    name: "fetch",
+    description: "Makes HTTP requests to APIs or endpoints. For testing APIs, fetching data, or making web requests. Not intended for reading web pages (HTML).",
+    inputs: [{
+        name: "url",
+        type: "string",
+        description: "The URL to fetch (e.g., 'https://api.example.com/data')",
+        required: true,
+    },
+    {
+        name: "method",
+        type: "string",
+        description: "HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS)",
+        required: false,
+        default: "GET"
+    },
+    {
+        name: "headers",
+        type: "object",
+        description: "HTTP headers as key-value pairs (e.g., {'Authorization': 'Bearer token', 'Content-Type': 'application/json'})",
+        required: false,
+    },
+    {
+        name: "body",
+        type: "string",
+        description: "Request body (required for POST, PUT, PATCH methods). Can be JSON string or form data.",
+        required: false,
+    },
+    {
+        name: "timeout",
+        type: "number",
+        description: "Request timeout in milliseconds (default: 30000)",
+        required: false,
+        default: 30000
+    }],
+    execute: async (_: string, inputs: Record<string, any>): Promise<any> => {
+        try {
+            const { url, method = "GET", headers = {}, body, timeout = 30000 } = inputs;
+
+            if (!url || typeof url !== "string") {
+                throw new Error("url must be a non-empty string");
+            }
+
+            try {
+                new URL(url);
+            } catch {
+                throw new Error(`Invalid URL format: ${url}`);
+            }
+
+            const validMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+            const normalizedMethod = method.toUpperCase();
+            if (!validMethods.includes(normalizedMethod)) {
+                throw new Error(`Invalid HTTP method: ${method}. Must be one of: ${validMethods.join(", ")}`);
+            }
+
+            if (body && ["GET", "HEAD", "OPTIONS"].includes(normalizedMethod)) {
+                throw new Error(`${normalizedMethod} requests cannot have a body`);
+            }
+
+            let parsedHeaders = headers;
+            if (typeof headers === "string") {
+                try {
+                    parsedHeaders = JSON.parse(headers);
+                } catch {
+                    throw new Error("headers must be a valid JSON object");
+                }
+            }
+
+            if (parsedHeaders && typeof parsedHeaders !== "object") {
+                throw new Error("headers must be an object or JSON string");
+            }
+
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+            try {
+                const fetchOptions: RequestInit = {
+                    method: normalizedMethod,
+                    headers: parsedHeaders || {},
+                    signal: controller.signal,
+                };
+
+                if (body) {
+                    const isJson = typeof body === "string" && (
+                        body.trim().startsWith("{") || 
+                        body.trim().startsWith("[")
+                    );
+                    
+                    if (isJson && !parsedHeaders?.["Content-Type"] && !parsedHeaders?.["content-type"]) {
+                        fetchOptions.headers = {
+                            ...parsedHeaders,
+                            "Content-Type": "application/json"
+                        };
+                    }
+                    fetchOptions.body = body;
+                }
+
+                const response = await fetch(url, fetchOptions);
+
+                clearTimeout(timeoutId);
+
+                const contentType = response.headers.get("content-type") || "";
+                let data;
+
+                if (contentType.includes("application/json")) {
+                    try {
+                        data = await response.json();
+                    } catch {
+                        data = await response.text();
+                    }
+                } else {
+                    data = await response.text();
+                }
+
+                const result = {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: Object.fromEntries(response.headers.entries()),
+                    data: data,
+                };
+
+                if (!response.ok) {
+                    return {
+                        ...result,
+                        error: `HTTP ${response.status}: ${response.statusText}`,
+                    };
+                }
+
+                return result;
+
+            } finally {
+                clearTimeout(timeoutId);
+            }
+
+        } catch (error) {
+            let errorMessage = error instanceof Error ? error.message : String(error);
+
+            if (error instanceof Error) {
+                if (error.name === "AbortError") {
+                    errorMessage = `Request timed out after ${inputs.timeout || 30000}ms`;
+                } else if (error.message.includes("ENOTFOUND")) {
+                    errorMessage = `DNS resolution failed: ${inputs.url}`;
+                } else if (error.message.includes("ECONNREFUSED")) {
+                    errorMessage = `Connection refused: ${inputs.url}`;
+                } else if (error.message.includes("ECONNRESET")) {
+                    errorMessage = `Connection reset by peer: ${inputs.url}`;
+                } else if (error.message.includes("ETIMEDOUT")) {
+                    errorMessage = `Connection timed out: ${inputs.url}`;
+                }
+            }
+
+            return {
+                error: errorMessage,
+            };
+        }
+    }
+});
+
+export default FetchTool;

package/src/tools/www/index.ts

@@ -0,0 +1,3 @@
+export { FetchTool } from "./fetch";
+export { WebSearchTool } from "./web-search";
+export { ReadWebPageTool } from "./read-web-page"

package/src/tools/www/read-web-page.ts

@@ -0,0 +1,350 @@
+import puppeteer, { Browser } from "puppeteer-core";
+import os from "os";
+import MCPTool from "../../core/mcp";
+
+export const ReadWebPageTool = new MCPTool({
+    name: "read-web-page",
+    description: "Retrieve and extract content from a specific URL. Use this when you need to read a webpage's HTML or convert it to clean markdown text. Ideal for reading articles, documentation, API responses, or any web content. Returns structured text without navigation menus or scripts.",
+    inputs: [{
+        name: "url",
+        type: "string",
+        description: `Complete URL including protocol (http:// or https://). Example: "https://example.com/page"`,
+        required: true,
+    },
+    {
+        name: "outputType",
+        type: "string",
+        description: `Output format: "text" returns clean markdown-formatted content without HTML tags (best for reading articles and text), "html" returns raw HTML source (use for debugging or when structure matters)`,
+        required: true,
+    }],
+    execute: async (_: string, inputs: Record<string, any>): Promise<any> => {
+        let browser: Browser | undefined;
+        try {
+            const url = inputs.url;
+            const outputType = inputs.outputType;
+            const maxWords = 5000;
+
+            if (!url || typeof url !== "string") {
+                throw new Error("Invalid parameter: 'url' must be a non-empty string like 'https://example.com'");
+            }
+
+            if (!url.match(/^https?:\/\//i)) {
+                throw new Error("Invalid URL format: URL must start with http:// or https://");
+            }
+
+            if (!outputType || typeof outputType !== "string") {
+                throw new Error("Invalid parameter: 'outputType' must be specified as either 'text' or 'html'");
+            }
+
+            if (outputType !== "text" && outputType !== "html") {
+                throw new Error(`Invalid outputType '${outputType}': must be 'text' or 'html'`);
+            }
+
+            browser = await puppeteer.launch({
+                executablePath: process.env.CHROME_PATH || (os.platform() == "win32" ?
+                    "C:/Program Files/Google/Chrome/Application/chrome.exe" :
+                    "/usr/bin/google-chrome-stable"),
+                headless: true,
+                args: ["--no-sandbox"],
+            });
+
+            const page = await browser.newPage();
+
+            await page.evaluateOnNewDocument(() => {
+                (window as any).__name = (fn: Function, _name: string) => fn;
+            });
+
+            await page.setUserAgent(
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+            );
+            await page.goto(url, { waitUntil: "networkidle0", timeout: 50000 });
+
+            if (outputType === "html") {
+                return await page.content();
+            }
+
+            const extracted = await page.evaluate(() => {
+                const getInnerText = (el: Element): string => {
+                    if (el instanceof HTMLElement) return el.innerText.trim();
+                    return el.textContent?.trim() || "";
+                };
+
+                const garbageSelectors = [
+                    "script", "style", "noscript", "iframe", "svg", "canvas",
+                    "nav", "footer", "header", "aside",
+                    ".sidebar", ".toc", ".menu", ".navigation", ".breadcrumb",
+                    ".advertisement", ".ads", ".popup", ".modal",
+                    ".feedback", ".rating", ".comment", ".social-share", ".share",
+                    ".social", ".related", ".recommended", ".popular", ".trending",
+                    ".footer-links", ".copyright", ".privacy", ".terms", ".cookie",
+                    ".consent", ".newsletter", ".subscribe", ".email-signup",
+                    ".download", ".app-promo", ".widget", ".right-rail", ".left-rail",
+                    ".sticky", ".floating", ".popover", ".tooltip", ".dropdown-menu",
+                    ".search", ".filter", ".sort", ".pagination", ".author-bio",
+                    ".meta", ".timestamp", ".category", ".tags", ".breadcrumb",
+                    ".video-player", ".audio-player", ".slider", ".carousel", ".tabs",
+                    ".accordion", ".collapse", ".toggle", ".share-buttons", ".print",
+                    ".pdf", ".download-link", ".external-link", ".like", ".vote",
+                    ".rating-stars", ".review", ".testimonial", ".footnote",
+                    ".reference", ".citation", ".table-of-contents", ".summary",
+                    ".abstract", ".excerpt", ".teaser", ".preview", ".thumbnail",
+                    ".avatar", ".profile", ".user", ".comment-author", ".comment-content",
+                    ".reply", ".thread", ".discussion", ".forum", ".chat-message",
+                    ".notification", ".alert", ".warning", ".error", ".success", ".info",
+                    ".banner", ".hero", ".jumbotron", ".cta", ".call-to-action",
+                    ".button-wrapper", ".btn-group", ".toolbar", ".controls",
+                    ".settings", ".preferences", ".language-selector", ".back-to-top",
+                    ".scroll-to-top", ".share-this", ".bookmark", ".favorite",
+                    ".poll", ".survey", ".quiz", ".load-more", ".infinite-scroll",
+                    ".spinner", ".loader", ".progress", ".visually-hidden", ".sr-only",
+                    "[role='navigation']", "[role='banner']", "[role='complementary']",
+                    "[aria-hidden='true']", ".ask-bloom", ".chat-widget", ".support-widget"
+                ];
+                garbageSelectors.forEach(sel => {
+                    document.querySelectorAll(sel).forEach(el => el.remove());
+                });
+
+                document.querySelectorAll("div, section, article").forEach(el => {
+                    if (!(el instanceof HTMLElement)) return;
+                    const text = el.innerText.trim();
+                    if (!text.length) return;
+                    const links = el.querySelectorAll("a");
+                    let linkTextLength = 0;
+                    links.forEach(link => {
+                        if (link instanceof HTMLElement) linkTextLength += link.innerText.length;
+                    });
+                    if (linkTextLength / text.length > 0.7) {
+                        el.remove();
+                    }
+                });
+
+                let mainContent: Element | null = null;
+
+                const candidates = [
+                    document.querySelector("main"),
+                    document.querySelector("article"),
+                    document.querySelector("[role='main']"),
+                    document.querySelector(".main-content"),
+                    document.querySelector(".content"),
+                    document.querySelector(".post-content"),
+                    document.querySelector(".prose"),
+                    document.querySelector("#content"),
+                    document.querySelector(".post"),
+                    document.querySelector(".entry"),
+                    document.querySelector(".article-content"),
+                    document.querySelector(".story"),
+                    document.querySelector(".body"),
+                    document.querySelector(".primary"),
+                    document.querySelector(".main"),
+                    document.querySelector(".column-main"),
+                    document.querySelector(".region-main"),
+                    document.querySelector(".node-content"),
+                    document.querySelector(".field-name-body"),
+                    document.querySelector(".body-field"),
+                    document.querySelector(".page-content"),
+                    document.querySelector(".post-body"),
+                    document.querySelector(".entry-content"),
+                    document.querySelector(".article-body"),
+                    document.querySelector(".blog-post"),
+                    document.querySelector(".single-post"),
+                    document.querySelector(".main-text"),
+                    document.querySelector(".primary-content"),
+                    document.querySelector(".content-area"),
+                    document.querySelector(".site-content"),
+                ];
+
+                for (const candidate of candidates) {
+                    if (candidate && getInnerText(candidate).length > 300) {
+                        mainContent = candidate;
+                        break;
+                    }
+                }
+
+                if (!mainContent) {
+                    let maxTextLen = 0;
+                    let bestEl: Element | null = null;
+                    const walker = document.createTreeWalker(
+                        document.body,
+                        NodeFilter.SHOW_ELEMENT,
+                        {
+                            acceptNode: (node) => {
+                                const el = node as Element;
+                                const tag = el.tagName.toLowerCase();
+                                if (["div", "section", "article", "main"].includes(tag)) {
+                                    return NodeFilter.FILTER_ACCEPT;
+                                }
+                                return NodeFilter.FILTER_SKIP;
+                            }
+                        }
+                    );
+                    while (walker.nextNode()) {
+                        const el = walker.currentNode as Element;
+                        const textLen = getInnerText(el).length;
+                        if (textLen > maxTextLen && textLen > 500) {
+                            maxTextLen = textLen;
+                            bestEl = el;
+                        }
+                    }
+                    mainContent = bestEl;
+                }
+
+                if (!mainContent) {
+                    mainContent = document.body;
+                    document.querySelectorAll("aside, .sidebar, nav, footer, header").forEach(el => el.remove());
+                }
+
+                function nodeToMd(node: Node, depth = 0): string {
+                    if (node.nodeType === 3) {
+                        return (node.textContent || "").replace(/\s+/g, " ");
+                    }
+                    if (node.nodeType !== 1) return "";
+
+                    const el = node as Element;
+                    const tag = el.tagName.toLowerCase();
+
+                    if (el instanceof HTMLElement) {
+                        const style = window.getComputedStyle(el);
+                        if (style.display === "none" || style.visibility === "hidden") return "";
+                    }
+
+                    const children = () => Array.from(el.childNodes).map(n => nodeToMd(n, depth)).join("");
+
+                    if (tag === "h1") return `\n\n# ${children().trim()}\n\n`;
+                    if (tag === "h2") return `\n\n## ${children().trim()}\n\n`;
+                    if (tag === "h3") return `\n\n### ${children().trim()}\n\n`;
+                    if (tag === "h4") return `\n\n#### ${children().trim()}\n\n`;
+                    if (tag === "h5") return `\n\n##### ${children().trim()}\n\n`;
+                    if (tag === "h6") return `\n\n###### ${children().trim()}\n\n`;
+
+                    if (tag === "br") return "\n";
+                    if (tag === "hr") return "\n\n---\n\n";
+
+                    if (["p", "div", "section", "article"].includes(tag)) {
+                        const inner = children().trim();
+                        return inner ? `\n\n${inner}\n\n` : "";
+                    }
+
+                    if (tag === "a") {
+                        const anchor = el as HTMLAnchorElement;
+                        const href = anchor.href;
+                        const text = children().trim();
+                        if (!text) return "";
+                        if (href.startsWith("#")) return text;
+                        if (href.startsWith("javascript:")) return text;
+                        if (href && href !== text && text.length > 0) return `[${text}](${href})`;
+                        return text;
+                    }
+
+                    if (tag === "img") {
+                        const img = el as HTMLImageElement;
+                        const alt = img.alt?.trim() || "";
+                        const src = img.src;
+                        if (!src || src.startsWith("data:")) return alt || "";
+                        return alt ? `![${alt}](${src})` : `![](${src})`;
+                    }
+
+                    if (["strong", "b"].includes(tag)) {
+                        const inner = children().trim();
+                        return inner ? `**${inner}**` : "";
+                    }
+                    if (["em", "i"].includes(tag)) {
+                        const inner = children().trim();
+                        return inner ? `*${inner}*` : "";
+                    }
+                    if (tag === "code") {
+                        const inner = children().trim();
+                        return inner ? `\`${inner}\`` : "";
+                    }
+                    if (tag === "pre") {
+                        const codeEl = el.querySelector("code");
+                        const lang = codeEl?.className.match(/language-(\w+)/)?.[1] || "";
+                        const text = (codeEl || el).textContent?.trim() || "";
+                        return text ? `\n\n\`\`\`${lang}\n${text}\n\`\`\`\n\n` : "";
+                    }
+
+                    if (tag === "blockquote") {
+                        const inner = children().trim();
+                        if (!inner) return "";
+                        return "\n\n" + inner.split("\n").map(l => `> ${l}`).join("\n") + "\n\n";
+                    }
+
+                    if (tag === "ul") {
+                        const items = Array.from(el.children)
+                            .filter(c => c.tagName.toLowerCase() === "li")
+                            .map(li => {
+                                const text = nodeToMd(li, depth + 1).trim();
+                                const indent = "  ".repeat(depth);
+                                return `${indent}- ${text}`;
+                            });
+                        return items.length ? `\n\n${items.join("\n")}\n\n` : "";
+                    }
+                    if (tag === "ol") {
+                        const items = Array.from(el.children)
+                            .filter(c => c.tagName.toLowerCase() === "li")
+                            .map((li, i) => {
+                                const text = nodeToMd(li, depth + 1).trim();
+                                const indent = "  ".repeat(depth);
+                                return `${indent}${i + 1}. ${text}`;
+                            });
+                        return items.length ? `\n\n${items.join("\n")}\n\n` : "";
+                    }
+                    if (tag === "li") return children();
+
+                    if (tag === "table") {
+                        const rows = Array.from(el.querySelectorAll("tr"));
+                        if (rows.length === 0) return "";
+                        const toRow = (row: Element) =>
+                            Array.from(row.querySelectorAll("th,td"))
+                                .map(cell => cell.textContent?.replace(/\s+/g, " ").trim() || "")
+                                .join(" | ");
+                        const firstRow = rows[0];
+                        if (!firstRow) return "";
+                        const isHeaderRow = firstRow.querySelectorAll("th").length > 0;
+                        const headerText = toRow(firstRow);
+                        const cols = firstRow.querySelectorAll("th,td").length;
+                        if (cols === 0) return "";
+                        const separator = Array(cols).fill("---").join(" | ");
+                        const dataRows = isHeaderRow ? rows.slice(1) : rows;
+                        const bodyLines = dataRows.map(r => `| ${toRow(r)} |`).join("\n");
+                        return `\n\n| ${headerText} |\n| ${separator} |\n${bodyLines}\n\n`;
+                    }
+
+                    return children();
+                }
+
+                let md = nodeToMd(mainContent);
+
+                md = md.replace(/\n{3,}/g, "\n\n");
+                md = md.replace(/[ \t]+$/gm, "");
+                md = md.trim();
+
+                return md;
+            });
+
+            let output = `# Source: ${url}\n\n${extracted}`;
+
+            const words = output.split(/\s+/);
+            if (words.length > maxWords) {
+                return words.slice(0, maxWords).join(" ") +
+                    `\n\n---\n*Truncated: ${words.length} words → ${maxWords} words*`;
+            }
+
+            if (!output) {
+                throw new Error(`Failed to fetch content from ${url} - received empty response`);
+            }
+
+            return {
+                content: output,
+                size: output.length
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : String(error),
+            };
+        } finally {
+            await browser?.close();
+        }
+    }
+});
+
+export default ReadWebPageTool;

package/src/tools/www/web-search.ts

@@ -0,0 +1,102 @@
+import os from "os";
+import puppeteer from "puppeteer-core";
+import MCPTool from "../../core/mcp";
+
+export const WebSearchTool = new MCPTool({
+    name: "web-search",
+    description: "Search the web for information, news, or resources. Returns titles, snippets, and URLs.",
+    inputs: [{
+        name: "query",
+        type: "string",
+        description: `Search term or phrase (e.g., "climate change effects", "Python tutorials")`,
+        required: true,
+    }],
+    execute: async (_: string, inputs: Record<string, any>): Promise<any> => {
+        try {
+            const query = inputs.query;
+
+            if (!query || typeof query !== "string") {
+                throw new Error(`Invalid parameter: "query" must be a non-empty search query string`);
+            }
+
+            const cleanedQuery = query.trim();
+
+            if (cleanedQuery.length === 0) {
+                throw new Error(`Invalid parameter: "query" cannot be empty or just whitespace`);
+            }
+
+            if (cleanedQuery.length > 500) {
+                throw new Error(`Search query is quite long (${cleanedQuery.length} chars). Consider shortening for better results.`);
+            }
+
+            const browser = await puppeteer.launch({
+                executablePath: process.env.CHROME_PATH || (os.platform() == "win32" ?
+                    "C:/Program Files/Google/Chrome/Application/chrome.exe" :
+                    "/usr/bin/google-chrome-stable"),
+                headless: true,
+                args: ["--no-sandbox"],
+            });
+
+            const page = await browser.newPage();
+
+            await page.setUserAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36");
+
+            await page.goto(
+                `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`,
+                { waitUntil: "networkidle0", timeout: 30000 }
+            );
+
+            await page.waitForSelector(".result", { timeout: 10000 });
+
+            const results = await page.evaluate(() => {
+                const resultElements = document.querySelectorAll(".result");
+
+                return Array.from(resultElements).map((el, i) => {
+                    const titleElement = el.querySelector(".result__a, .result-title, a.result__url");
+                    const title = titleElement?.textContent?.trim() || "";
+
+                    let url = "";
+                    const linkElement = titleElement as HTMLAnchorElement;
+                    if (linkElement?.href) {
+                        url = linkElement.href;
+                        try {
+                            const urlParams = new URLSearchParams(linkElement.href.split("?")[1]);
+                            const uddg = urlParams.get("uddg");
+                            if (uddg) {
+                                url = decodeURIComponent(uddg);
+                            }
+                        } catch (e) { }
+                    }
+
+                    const snippetElement = el.querySelector(".result__snippet, .result-snippet, .snippet");
+                    const snippet = snippetElement?.textContent?.trim() || "";
+
+                    return {
+                        title,
+                        url,
+                        snippet,
+                    };
+                }).filter((r) => r.title && r.url && r.url.startsWith("http"));
+            });
+
+            await browser.close();
+
+            if (results.length === 0) {
+                console.log("No results found for:", query);
+                return [];
+            }
+
+            if (!results || (Array.isArray(results) && results.length === 0)) {
+                throw new Error(`No results found for your search query`);
+            }
+
+            return results;
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+});
+
+export default WebSearchTool;