hasolidit-mcp 0.0.1

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "hasolidit-mcp",
+  "version": "0.0.1",
+  "author": "Daniel Golub",
+  "license": "CC-BY-NC-4.0",
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.ts",
+    "lint": "eslint src/ tests/",
+    "lint:fix": "eslint src/ tests/ --fix",
+    "test": "npx playwright test",
+    "fixtures:update": "node scripts/capture-fixtures.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "playwright": "^1.52.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.52.0",
+    "@types/node": "^24.0.0",
+    "eslint": "^10.5.0",
+    "typescript-eslint": "^8.61.0"
+  }
+}

package/playwright.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  testDir: "./tests",
+  timeout: 60000,
+  testIgnore: process.env.CI ? /search\.test/ : undefined,
+  use: {
+    headless: true,
+    userAgent:
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36",
+    locale: "he-IL",
+  },
+});

package/scripts/capture-fixtures.ts

@@ -0,0 +1,44 @@
+import { chromium } from "playwright";
+import { writeFileSync, mkdirSync } from "fs";
+
+mkdirSync("fixtures", { recursive: true });
+
+const browser = await chromium.launch();
+const ctx = await browser.newContext({
+  userAgent:
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36",
+  locale: "he-IL",
+});
+
+// Search results
+console.log("Capturing search results...");
+let page = await ctx.newPage();
+await page.goto("https://www.hasolidit.com/kehila/search/?type=post");
+await page
+  .locator('input[type="search"][name="keywords"]')
+  .fill("קרן השתלמות");
+await page.getByRole("button", { name: "חיפוש" }).click();
+await page.waitForSelector(".contentRow", { timeout: 15000 });
+writeFileSync("fixtures/search-results.html", await page.content());
+console.log("  Saved fixtures/search-results.html");
+
+// Thread
+console.log("Capturing thread...");
+page = await ctx.newPage();
+await page.goto(
+  "https://www.hasolidit.com/kehila/threads/%D7%94%D7%90%D7%9D-%D7%A2%D7%9C%D7%99-%D7%9C%D7%91%D7%A8%D7%95%D7%97-%D7%9E%D7%99%D7%A9%D7%A8%D7%90%D7%9C.34810/"
+);
+await page.waitForSelector(".message--post", { timeout: 15000 });
+writeFileSync("fixtures/thread.html", await page.content());
+console.log("  Saved fixtures/thread.html");
+
+// New posts
+console.log("Capturing new posts...");
+page = await ctx.newPage();
+await page.goto("https://www.hasolidit.com/kehila/whats-new/posts/");
+await page.waitForSelector(".structItem--thread", { timeout: 15000 });
+writeFileSync("fixtures/new-posts.html", await page.content());
+console.log("  Saved fixtures/new-posts.html");
+
+await browser.close();
+console.log("Done.");

package/src/browser.ts

@@ -0,0 +1,26 @@
+import { chromium, type Browser, type BrowserContext } from "playwright";
+
+let browser: Browser | null = null;
+
+export async function getBrowser(): Promise<Browser> {
+  if (!browser) {
+    browser = await chromium.launch({ headless: true });
+  }
+  return browser;
+}
+
+export async function newContext(): Promise<BrowserContext> {
+  const b = await getBrowser();
+  return b.newContext({
+    userAgent:
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36",
+    locale: "he-IL",
+  });
+}
+
+export async function closeBrowser(): Promise<void> {
+  if (browser) {
+    await browser.close();
+    browser = null;
+  }
+}

package/src/index.ts

@@ -0,0 +1,89 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { searchForum } from "./tools/search.ts";
+import { viewThread } from "./tools/view-thread.ts";
+import { getNewPosts } from "./tools/new-posts.ts";
+import { closeBrowser } from "./browser.ts";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+
+const server = new McpServer({
+  name: "hasolidit",
+  version,
+});
+
+server.tool(
+  "search_forum",
+  "Search the Hasolidit financial community forum. Returns titles, snippets, authors, dates, and links.",
+  {
+    query: z.string().describe("Search query (Hebrew or English)"),
+    page: z
+      .number()
+      .int()
+      .positive()
+      .optional()
+      .default(1)
+      .describe("Results page number (default 1)"),
+  },
+  async ({ query, page }) => {
+    const result = await searchForum(query, page);
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
+
+server.tool(
+  "view_thread",
+  "View a thread from the Hasolidit forum. Returns all posts with author, date, and content.",
+  {
+    url: z
+      .string()
+      .url()
+      .describe("Full URL of the thread to view"),
+    page: z
+      .number()
+      .int()
+      .positive()
+      .optional()
+      .default(1)
+      .describe("Thread page number (default 1)"),
+  },
+  async ({ url, page }) => {
+    const result = await viewThread(url, page);
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
+
+server.tool(
+  "new_posts",
+  "Get the latest active threads from the Hasolidit forum. Returns recently active threads with title, author, forum, reply/view counts, and last activity info.",
+  {},
+  async () => {
+    const result = await getNewPosts();
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  process.on("SIGINT", async () => {
+    await closeBrowser();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await closeBrowser();
+    process.exit(0);
+  });
+}
+
+main();

package/src/tools/new-posts.ts

@@ -0,0 +1,82 @@
+import { newContext } from "../browser.ts";
+
+const URL = "https://www.hasolidit.com/kehila/whats-new/posts/";
+
+export interface NewPostThread {
+  title: string;
+  url: string;
+  author: string;
+  forum: string;
+  replies: string;
+  views: string;
+  lastActivityDate: string;
+  lastPoster: string;
+}
+
+export interface NewPostsResponse {
+  threads: NewPostThread[];
+}
+
+export async function getNewPosts(): Promise<NewPostsResponse> {
+  const context = await newContext();
+  try {
+    const p = await context.newPage();
+
+    await p.goto(URL);
+    await p.waitForSelector(".structItem--thread", { timeout: 15000 });
+
+    const threads = await p.evaluate(() => {
+      return Array.from(
+        document.querySelectorAll(".structItem--thread")
+      ).map((item) => {
+        const titleEl = item.querySelector(".structItem-title a");
+        const title = titleEl?.textContent?.trim() ?? "";
+        const href = titleEl?.getAttribute("href") ?? "";
+        const url = href.startsWith("http")
+          ? href
+          : `https://www.hasolidit.com${href}`;
+
+        const parts = item.querySelectorAll(".structItem-parts li");
+        const author =
+          parts[0]?.querySelector(".username")?.textContent?.trim() ?? "";
+
+        const forumEl = item.querySelector(
+          '.structItem-parts a[href*="/forums/"]'
+        );
+        const forum = forumEl?.textContent?.trim() ?? "";
+
+        const metaDds = item.querySelectorAll(
+          ".structItem-cell--meta .pairs dd"
+        );
+        const replies = metaDds[0]?.textContent?.trim() ?? "0";
+        const views = metaDds[1]?.textContent?.trim() ?? "0";
+
+        const latestTime = item.querySelector(
+          ".structItem-cell--latest time"
+        );
+        const lastActivityDate =
+          latestTime?.getAttribute("datetime") ?? "";
+
+        const lastPoster =
+          item
+            .querySelector(".structItem-cell--latest .username")
+            ?.textContent?.trim() ?? "";
+
+        return {
+          title,
+          url,
+          author,
+          forum,
+          replies,
+          views,
+          lastActivityDate,
+          lastPoster,
+        };
+      });
+    });
+
+    return { threads };
+  } finally {
+    await context.close();
+  }
+}

package/src/tools/search.ts

@@ -0,0 +1,111 @@
+import { newContext } from "../browser.ts";
+
+const BASE_URL = "https://www.hasolidit.com/kehila";
+
+export interface SearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+  author: string;
+  date: string;
+  forum: string;
+  replyCount: string | null;
+}
+
+export interface SearchResponse {
+  query: string;
+  page: number;
+  totalPages: number;
+  results: SearchResult[];
+}
+
+export async function searchForum(
+  query: string,
+  page: number = 1
+): Promise<SearchResponse> {
+  const context = await newContext();
+  try {
+    const p = await context.newPage();
+
+    // Navigate to search page
+    await p.goto(`${BASE_URL}/search/?type=post`);
+
+    // Fill and submit search form
+    await p.locator('input[type="search"][name="keywords"]').fill(query);
+    await p.getByRole("button", { name: "חיפוש" }).click();
+
+    // Wait for results page
+    await p.waitForSelector(".contentRow", { timeout: 15000 });
+
+    // If requesting a page beyond 1, navigate to it
+    if (page > 1) {
+      const currentUrl = p.url();
+      const url = new URL(currentUrl);
+      url.searchParams.set("page", String(page));
+      await p.goto(url.toString());
+      await p.waitForSelector(".contentRow", { timeout: 10000 });
+    }
+
+    // Extract pagination
+    const totalPages = await extractTotalPages(p);
+
+    // Extract results
+    const rows = p.locator(".contentRow");
+    const count = await rows.count();
+    const results: SearchResult[] = [];
+
+    for (let i = 0; i < count; i++) {
+      const row = rows.nth(i);
+
+      const titleEl = row.locator(".contentRow-title a");
+      const title = (await titleEl.textContent()) ?? "";
+      const href = (await titleEl.getAttribute("href")) ?? "";
+      const url = href.startsWith("http")
+        ? href
+        : `https://www.hasolidit.com${href}`;
+
+      const snippet =
+        (await row.locator(".contentRow-snippet").textContent()) ?? "";
+
+      const minor = row.locator(".contentRow-minor .listInline li");
+      const minorCount = await minor.count();
+      const minorTexts: string[] = [];
+      for (let j = 0; j < minorCount; j++) {
+        minorTexts.push(
+          ((await minor.nth(j).textContent()) ?? "").trim()
+        );
+      }
+
+      // First item is author, date is usually 3rd, forum is last with "פורום:" prefix
+      const author = minorTexts[0] ?? "";
+      const date = minorTexts[2] ?? "";
+      const forumEntry = minorTexts.find((t) => t.startsWith("פורום:"));
+      const forum = forumEntry?.replace("פורום: ", "") ?? "";
+      const replyEntry = minorTexts.find((t) => t.startsWith("תגובות:"));
+      const replyCount = replyEntry?.replace("תגובות: ", "") ?? null;
+
+      results.push({
+        title: title.trim(),
+        url,
+        snippet: snippet.trim(),
+        author,
+        date,
+        forum,
+        replyCount,
+      });
+    }
+
+    return { query, page, totalPages, results };
+  } finally {
+    await context.close();
+  }
+}
+
+async function extractTotalPages(
+  p: import("playwright").Page
+): Promise<number> {
+  const pageNav = p.locator(".pageNav-page").last();
+  if ((await pageNav.count()) === 0) return 1;
+  const lastPageText = (await pageNav.textContent()) ?? "1";
+  return parseInt(lastPageText.trim(), 10) || 1;
+}

package/src/tools/view-thread.ts

@@ -0,0 +1,85 @@
+import { newContext } from "../browser.ts";
+
+export interface Post {
+  author: string;
+  date: string;
+  content: string;
+  postUrl: string;
+}
+
+export interface ThreadResponse {
+  title: string;
+  url: string;
+  page: number;
+  totalPages: number;
+  posts: Post[];
+}
+
+export async function viewThread(
+  url: string,
+  page: number = 1
+): Promise<ThreadResponse> {
+  const context = await newContext();
+  try {
+    const p = await context.newPage();
+
+    // XenForo pagination: append page-N to the URL path
+    let targetUrl = url;
+    if (page > 1) {
+      targetUrl = url.replace(/\/$/, "") + `/page-${page}`;
+    }
+
+    await p.goto(targetUrl);
+    await p.waitForSelector(".message--post", { timeout: 15000 });
+
+    // Extract everything in a single evaluate call — avoids per-element timeouts
+    const data = await p.evaluate(() => {
+      const title =
+        document.querySelector("h1.p-title-value")?.textContent?.trim() ?? "";
+
+      const lastPageEl = document.querySelector(
+        ".pageNav-page:last-child a"
+      );
+      const totalPages = lastPageEl
+        ? parseInt(lastPageEl.textContent?.trim() ?? "1", 10) || 1
+        : 1;
+
+      const posts = Array.from(
+        document.querySelectorAll("article.message--post")
+      ).map((article) => {
+        const author =
+          article.querySelector("h4.message-name")?.textContent?.trim() ?? "";
+
+        const timeEl = article.querySelector(
+          ".message-attribution-main time"
+        );
+        const date = timeEl?.getAttribute("datetime") ?? "";
+
+        const bbWrapper = article.querySelector(".message-body .bbWrapper");
+        const content = bbWrapper?.textContent?.trim() ?? "";
+
+        const postLink = article.querySelector(
+          "a.message-attribution-gadget"
+        );
+        const postHref = postLink?.getAttribute("href") ?? "";
+
+        return { author, date, content, postHref };
+      });
+
+      return { title, totalPages, posts };
+    });
+
+    const posts: Post[] = data.posts.map((p) => ({
+      author: p.author,
+      date: p.date,
+      content: p.content,
+      postUrl: p.postHref.startsWith("http")
+        ? p.postHref
+        : `https://www.hasolidit.com${p.postHref}`,
+    }));
+
+    return { title: data.title, url: targetUrl, page, totalPages: data.totalPages, posts };
+  } finally {
+    await context.close();
+  }
+}

package/tests/AGENTS.md

@@ -0,0 +1,32 @@
+# Tests
+
+E2E tests using Playwright against the Hasolidit forum.
+
+## Running tests
+
+- `npm test` — runs all tests locally against the live site, or fixtures in CI
+
+## Local vs CI
+
+- **Locally**: all 6 tests run against the live site (real browser, real network)
+- **CI**: tests use saved HTML fixtures from `fixtures/`. Search tests are skipped in CI because they require form interaction that can't be replayed from a static fixture.
+
+## How it works
+
+Tests import `test` and `expect` from `./test.ts` (not `@playwright/test` directly). This custom fixture automatically intercepts network requests in CI and serves saved HTML from `fixtures/`. Locally it passes through to the real site unchanged.
+
+## Adding tests
+
+1. Import from `./test.ts`: `import { test, expect } from "./test.ts";`
+2. Write tests using standard Playwright API — they work against the live site
+3. If the test hits a new URL pattern, add a route mapping in `tests/test.ts` and capture a fixture for it
+
+## Timeouts
+
+- Test timeout: 60s (set in `playwright.config.ts`)
+- `waitForSelector` timeout: 30s per call
+- CI retries: 1
+
+## Note
+
+These tests validate that our DOM selectors match the real site structure. If the site changes its HTML, tests will fail locally — update selectors and run `npm run fixtures:update` to recapture.

package/tests/new-posts.test.ts

@@ -0,0 +1,60 @@
+import { test, expect } from "./test.ts";
+
+const URL = "https://www.hasolidit.com/kehila/whats-new/posts/";
+
+test.describe("new_posts", () => {
+  test("loads recent threads with expected structure", async ({ page }) => {
+    await page.goto(URL);
+    await page.waitForSelector(".structItem--thread", { timeout: 30000 });
+
+    const items = page.locator(".structItem--thread");
+    const count = await items.count();
+    expect(count).toBeGreaterThan(0);
+
+    // First thread has a title with a link
+    const first = items.first();
+    const titleLink = first.locator(".structItem-title a").first();
+    const title = await titleLink.textContent();
+    expect(title?.trim().length).toBeGreaterThan(0);
+
+    const href = await titleLink.getAttribute("href");
+    expect(href).toContain("/threads/");
+
+    // Has an author
+    const author = await first
+      .locator(".structItem-parts .username")
+      .first()
+      .textContent();
+    expect(author?.trim().length).toBeGreaterThan(0);
+
+    // Has reply count
+    const replies = await first
+      .locator(".structItem-cell--meta .pairs dd")
+      .first()
+      .textContent();
+    expect(replies?.trim()).toBeTruthy();
+
+    // Has last activity date
+    const latestTime = first.locator(".structItem-cell--latest time");
+    const datetime = await latestTime.getAttribute("datetime");
+    expect(datetime).toBeTruthy();
+
+    // Has last poster
+    const lastPoster = await first
+      .locator(".structItem-cell--latest .username")
+      .textContent();
+    expect(lastPoster?.trim().length).toBeGreaterThan(0);
+  });
+
+  test("has forum info for threads", async ({ page }) => {
+    await page.goto(URL);
+    await page.waitForSelector(".structItem--thread", { timeout: 30000 });
+
+    const first = page.locator(".structItem--thread").first();
+    const forumLink = first.locator(
+      '.structItem-parts a[href*="/forums/"]'
+    );
+    const forum = await forumLink.textContent();
+    expect(forum?.trim().length).toBeGreaterThan(0);
+  });
+});

package/tests/search.test.ts

@@ -0,0 +1,65 @@
+import { test, expect } from "./test.ts";
+
+const BASE_URL = "https://www.hasolidit.com/kehila";
+
+test.describe("search_forum", () => {
+  test("returns results for a known query", async ({ page }) => {
+    // Navigate to search page
+    await page.goto(`${BASE_URL}/search/?type=post`);
+
+    // Fill and submit
+    await page.locator('input[type="search"][name="keywords"]').fill("קרן השתלמות");
+    await page.getByRole("button", { name: "חיפוש" }).click();
+
+    // Wait for results
+    await page.waitForSelector(".contentRow", { timeout: 30000 });
+
+    // Verify results exist
+    const rows = page.locator(".contentRow");
+    const count = await rows.count();
+    expect(count).toBeGreaterThan(0);
+
+    // Verify first result has expected structure
+    const first = rows.first();
+    const title = await first.locator(".contentRow-title a").textContent();
+    expect(title?.trim().length).toBeGreaterThan(0);
+
+    const href = await first
+      .locator(".contentRow-title a")
+      .getAttribute("href");
+    expect(href).toBeTruthy();
+
+    const snippet = await first
+      .locator(".contentRow-snippet")
+      .textContent();
+    expect(snippet?.trim().length).toBeGreaterThan(0);
+
+    // Verify metadata
+    const minorItems = first.locator(".contentRow-minor .listInline li");
+    const minorCount = await minorItems.count();
+    expect(minorCount).toBeGreaterThanOrEqual(3); // author, type, date at minimum
+  });
+
+  test("pagination works", async ({ page }) => {
+    await page.goto(`${BASE_URL}/search/?type=post`);
+    await page.locator('input[type="search"][name="keywords"]').fill("מס הכנסה");
+    await page.getByRole("button", { name: "חיפוש" }).click();
+    await page.waitForSelector(".contentRow", { timeout: 30000 });
+
+    // Check pagination exists
+    const pageNav = page.locator(".pageNav-page");
+    const pageCount = await pageNav.count();
+    expect(pageCount).toBeGreaterThan(1);
+
+    // Navigate to page 2
+    const currentUrl = page.url();
+    const url = new URL(currentUrl);
+    url.searchParams.set("page", "2");
+    await page.goto(url.toString());
+    await page.waitForSelector(".contentRow", { timeout: 30000 });
+
+    // Verify page 2 has results
+    const rows = page.locator(".contentRow");
+    expect(await rows.count()).toBeGreaterThan(0);
+  });
+});

package/tests/test.ts

@@ -0,0 +1,31 @@
+import { test as base } from "@playwright/test";
+import { readFileSync } from "fs";
+import { join } from "path";
+
+export { expect } from "@playwright/test";
+
+const fixtureDir = join(import.meta.dirname, "..", "fixtures");
+
+const routes: [string, string][] = [
+  ["**/kehila/search/**", "search-results.html"],
+  ["**/kehila/threads/**", "thread.html"],
+  ["**/kehila/whats-new/posts/**", "new-posts.html"],
+];
+
+export const test = process.env.CI
+  ? base.extend({
+      page: async ({ page }, use) => {
+        for (const [pattern, file] of routes) {
+          const html = readFileSync(join(fixtureDir, file), "utf-8");
+          await page.route(pattern, (route) =>
+            route.fulfill({
+              status: 200,
+              contentType: "text/html",
+              body: html,
+            })
+          );
+        }
+        await use(page);
+      },
+    })
+  : base;