@sportsbarwatch/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,102 @@
+# SportsBarWatch MCP Server
+
+Find sports bars showing live matches worldwide — World Cup 2026, Premier League, Champions League, and 30+ sports across 2,000+ bars in 99 countries.
+
+An [MCP (Model Context Protocol)](https://modelcontextprotocol.io) server that lets AI assistants answer questions like:
+
+- "Where can I watch Arsenal vs Chelsea in London?"
+- "What's on at sports bars in Stockholm tonight?"
+- "Find bars showing the World Cup in Tokyo"
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `find_bars_showing_match` | Find bars showing a specific match by team name or match ID |
+| `whats_on_tonight` | Get all matches showing at bars tonight in a city |
+| `bar_details` | Get full details about a bar including upcoming matches |
+| `search_matches` | Search matches by team, competition, or sport |
+| `team_schedule` | Get upcoming schedule for a team with bar counts |
+
+## Quick Start
+
+### With Claude Desktop
+
+Add to your config (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "sportsbarwatch": {
+      "command": "npx",
+      "args": ["-y", "@sportsbarwatch/mcp-server"],
+      "env": {
+        "SBW_DB_PATH": "/path/to/vargarmatchen.db"
+      }
+    }
+  }
+}
+```
+
+### With Claude Code
+
+```bash
+claude mcp add sportsbarwatch -- npx -y @sportsbarwatch/mcp-server
+```
+
+### From source
+
+```bash
+git clone https://github.com/eliastuff/vargarmatchen
+cd vargarmatchen/mcp-server
+npm install && npm run build
+node dist/index.js
+```
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `SBW_DB_PATH` | Path to SQLite database | `../data/vargarmatchen.db` |
+| `SBW_TELEMETRY` | Set to `off` to disable demand logging | `on` |
+
+## Anonymous Demand Logging
+
+By default, the server logs anonymous demand signals (team + city + result count) to a local SQLite file (`mcp-demand.db`) next to the main database. This helps us understand which cities and teams have unmet demand so we can expand bar coverage.
+
+**What is logged:** tool name, team/query (truncated to 80 chars, sanitized), city (bucketed to "[small city]" when fewer than 5 bars), sport, result count, date. One entry per unique combination per day. Data retained for 365 days.
+
+**What is NOT logged:** no IP, no user identity, no device ID, no session tracking. Query inputs are truncated and sanitized — not raw conversation content.
+
+**Opt out:** Set `SBW_TELEMETRY=off` in your environment.
+
+## Data
+
+The server reads from a SQLite database (read-only, no writes) containing:
+
+- **2,000+ bars** across 99 countries and 680+ cities
+- **Daily-updated** match schedules from 188 automated scrapers
+- **30+ sports**: football, ice hockey, basketball, tennis, rugby, motorsport, and more
+- **World Cup 2026**: all 48 teams, group stage schedule, host city venues
+
+Data is scraped daily from bar websites via GitHub Actions. Major chains include O'Learys, Walkabout, Social Pub & Kitchen, Belushi's, and hundreds of independent sports bars.
+
+## Example Queries
+
+Ask your AI assistant:
+
+- "Where can I watch the Champions League final in Berlin?"
+- "What sports bars in Melbourne are showing AFL tonight?"
+- "Find a bar showing England vs Croatia in the World Cup in London"
+- "What's the schedule for Real Madrid this week?"
+- "Tell me about O'Learys TOLV in Stockholm"
+
+## Links
+
+- **Website**: [sportsbarwatch.com](https://sportsbarwatch.com)
+- **GitHub**: [eliastuff/vargarmatchen](https://github.com/eliastuff/vargarmatchen)
+- **World Cup 2026**: [sportsbarwatch.com/worldcup](https://sportsbarwatch.com/worldcup)
+
+## License
+
+MIT

package/dist/db.d.ts

@@ -0,0 +1,4 @@
+import Database from "better-sqlite3";
+export declare function getDb(): Database.Database;
+/** Writable demand logging database — separate from main DB to preserve read-only guarantee */
+export declare function getDemandDb(): Database.Database | null;

package/dist/db.js

@@ -0,0 +1,55 @@
+import Database from "better-sqlite3";
+import path from "path";
+const DB_PATH = process.env.SBW_DB_PATH
+    || (process.env.FLY_APP_NAME ? "/data/vargarmatchen.db" : path.join(process.cwd(), "..", "data", "vargarmatchen.db"));
+const DEMAND_DB_PATH = process.env.SBW_DEMAND_DB_PATH
+    || path.join(path.dirname(DB_PATH), "mcp-demand.db");
+let db = null;
+let demandDb = null;
+let demandDbFailed = false; // Don't retry if init failed (read-only FS, etc.)
+export function getDb() {
+    if (!db) {
+        db = new Database(DB_PATH, { readonly: true });
+        db.pragma("journal_mode = WAL");
+    }
+    return db;
+}
+/** Writable demand logging database — separate from main DB to preserve read-only guarantee */
+export function getDemandDb() {
+    if (demandDbFailed)
+        return null;
+    if (!demandDb) {
+        try {
+            demandDb = new Database(DEMAND_DB_PATH);
+            demandDb.pragma("journal_mode = WAL");
+            // Drop and recreate on schema change — demand data is ephemeral/local, no migration needed
+            const tableInfo = demandDb.prepare(`PRAGMA table_info(mcp_demand)`).all();
+            const needsRecreate = tableInfo.length > 0 && tableInfo.some(c => c.name === "team" && c.notnull === 0);
+            if (needsRecreate) {
+                demandDb.exec(`DROP TABLE IF EXISTS mcp_demand`);
+            }
+            demandDb.exec(`
+      CREATE TABLE IF NOT EXISTS mcp_demand (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        tool TEXT NOT NULL,
+        team TEXT NOT NULL DEFAULT '',
+        city TEXT NOT NULL DEFAULT '',
+        sport TEXT NOT NULL DEFAULT '',
+        results INTEGER NOT NULL DEFAULT 0,
+        date TEXT NOT NULL DEFAULT (date('now')),
+        UNIQUE(tool, team, city, date)
+      );
+      CREATE INDEX IF NOT EXISTS idx_demand_date ON mcp_demand(date);
+      CREATE INDEX IF NOT EXISTS idx_demand_city ON mcp_demand(city);
+    `);
+            // Prune entries older than 365 days to prevent unbounded growth
+            demandDb.exec(`DELETE FROM mcp_demand WHERE date < date('now', '-365 days')`);
+        }
+        catch (err) {
+            demandDbFailed = true;
+            console.error("[demand] DB init failed (read-only FS?):", err.message);
+            return null;
+        }
+    }
+    return demandDb;
+}

package/dist/demand.d.ts

@@ -0,0 +1,7 @@
+export declare function logDemand(params: {
+    tool: string;
+    team?: string;
+    city?: string;
+    sport?: string;
+    results: number;
+}): void;

package/dist/demand.js

@@ -0,0 +1,55 @@
+import { getDemandDb, getDb } from "./db.js";
+const TELEMETRY_ENABLED = process.env.SBW_TELEMETRY !== "off";
+// Cities with fewer than this many bars get bucketed as "[small city]" for privacy
+const MIN_BARS_FOR_CITY_NAME = 5;
+// Cache bar counts per city to avoid repeated queries
+let cityBarCounts = null;
+function getCityBarCount(city) {
+    if (!cityBarCounts) {
+        cityBarCounts = new Map();
+        try {
+            const rows = getDb().prepare(`SELECT city, COUNT(*) as cnt FROM bars GROUP BY city`).all();
+            for (const r of rows)
+                cityBarCounts.set(r.city, r.cnt);
+        }
+        catch {
+            // If main DB isn't available, bucket all cities for privacy safety
+            return 0;
+        }
+    }
+    return cityBarCounts.get(city) || 0;
+}
+function bucketCity(city) {
+    if (!city)
+        return null;
+    return getCityBarCount(city) >= MIN_BARS_FOR_CITY_NAME ? city : "[small city]";
+}
+/**
+ * Log an anonymous demand signal. Deduplicates by tool+team+city per day.
+ * Only logs the highest results count per dedup key per day.
+ */
+// Truncate and sanitize input to prevent storing arbitrary user text
+function sanitize(input, maxLen = 80) {
+    if (!input)
+        return "";
+    return input.slice(0, maxLen).replace(/[\n\r\t]/g, " ").trim();
+}
+export function logDemand(params) {
+    if (!TELEMETRY_ENABLED)
+        return;
+    try {
+        const db = getDemandDb();
+        if (!db)
+            return;
+        const city = bucketCity(params.city);
+        db.prepare(`INSERT INTO mcp_demand (tool, team, city, sport, results)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(tool, team, city, date) DO UPDATE SET
+         results = MAX(results, excluded.results),
+         sport = CASE WHEN excluded.sport != '' THEN excluded.sport ELSE sport END`).run(params.tool, sanitize(params.team), city || "", sanitize(params.sport), params.results);
+    }
+    catch (err) {
+        // Never break tool responses, but log to stderr for debugging
+        console.error("[demand] write failed:", err.message);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,142 @@
+#!/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 { findBarsShowingMatch, whatsOnTonight, barDetails, searchMatches, teamSchedule } from "./tools.js";
+import { checkRateLimit } from "./rate-limit.js";
+import { logDemand } from "./demand.js";
+const server = new McpServer({
+    name: "sportsbarwatch",
+    version: "0.1.0",
+});
+// Session ID for rate limiting (one per MCP connection)
+const sessionId = process.env.SBW_API_KEY || `session-${Date.now()}`;
+function rateLimitGuard() {
+    const { allowed, remaining } = checkRateLimit(sessionId);
+    if (!allowed) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Rate limit exceeded (100 queries/day). Contact hello@sportsbarwatch.com for higher limits.`,
+                }],
+        };
+    }
+    return null;
+}
+server.tool("find_bars_showing_match", "Find bars showing a specific match. Give team names, match description, or match ID, plus optional city to filter.", {
+    query: z.string().describe("Team name(s), match description, or match ID. E.g. 'Arsenal vs Chelsea' or 'Arsenal'"),
+    city: z.string().optional().describe("City to filter bars. E.g. 'Stockholm', 'London'"),
+    sport: z.string().optional().describe("Sport hint for telemetry. E.g. 'Fotboll', 'Ishockey'. Does not filter results (yet)."),
+}, async ({ query, city, sport }) => {
+    const blocked = rateLimitGuard();
+    if (blocked)
+        return blocked;
+    const result = findBarsShowingMatch(query, city);
+    logDemand({ tool: "find_bars_showing_match", team: query, city, sport, results: result.bars.length });
+    if (!result.match) {
+        return { content: [{ type: "text", text: `No upcoming matches found for "${query}".` }] };
+    }
+    const matchStr = `${result.match.home_team} vs ${result.match.away_team} (${result.match.competition}) — ${result.match.date_time}`;
+    const barsStr = result.bars.length > 0
+        ? result.bars.map((b) => `- ${b.name}, ${b.address}, ${b.area}, ${b.city}${b.phone ? ` (${b.phone})` : ""}`).join("\n")
+        : "No bars found showing this match" + (city ? ` in ${city}` : "") + ".";
+    return {
+        content: [{
+                type: "text",
+                text: `Match: ${matchStr}\n\n${result.bars.length} bar(s):\n${barsStr}\n\nMore info: https://sportsbarwatch.com/match/${result.match.id}`,
+            }],
+    };
+});
+server.tool("whats_on_tonight", "Get all matches being shown at bars tonight in a specific city.", {
+    city: z.string().describe("City name. E.g. 'Stockholm', 'London', 'Berlin'"),
+}, async ({ city }) => {
+    const blocked = rateLimitGuard();
+    if (blocked)
+        return blocked;
+    const result = whatsOnTonight(city);
+    logDemand({ tool: "whats_on_tonight", city, results: result.matches.length });
+    if (result.matches.length === 0) {
+        return { content: [{ type: "text", text: `No matches showing tonight in ${city}.` }] };
+    }
+    const lines = result.matches.map((m) => `- ${m.date_time.slice(11, 16)} | ${m.home_team} vs ${m.away_team} (${m.competition}) — ${m.bar_count} bar(s)`).join("\n");
+    return {
+        content: [{
+                type: "text",
+                text: `${result.matches.length} match(es) tonight in ${city}:\n\n${lines}\n\nFull schedule: https://sportsbarwatch.com/tonight/${encodeURIComponent(city)}`,
+            }],
+    };
+});
+server.tool("bar_details", "Get full details about a specific bar including address, contact info, and upcoming matches.", {
+    bar: z.string().describe("Bar name or ID. E.g. 'O'Learys Södermalm' or 'olearys-sodermalm'"),
+}, async ({ bar }) => {
+    const blocked = rateLimitGuard();
+    if (blocked)
+        return blocked;
+    const result = barDetails(bar);
+    logDemand({ tool: "bar_details", results: result.bar ? 1 : 0 });
+    if (!result.bar) {
+        return { content: [{ type: "text", text: `Bar "${bar}" not found.` }] };
+    }
+    const b = result.bar;
+    const info = [
+        `${b.name}`,
+        `${b.address}, ${b.area}, ${b.city}, ${b.country}`,
+        b.phone ? `Phone: ${b.phone}` : null,
+        result.tags.length > 0 ? `Tags: ${result.tags.join(", ")}` : null,
+        "",
+        `${result.matches.length} upcoming match(es):`,
+        ...result.matches.map((m) => `- ${m.date_time.slice(0, 16)} | ${m.home_team} vs ${m.away_team} (${m.competition})`),
+    ].filter(Boolean).join("\n");
+    return {
+        content: [{
+                type: "text",
+                text: `${info}\n\nMore info: https://sportsbarwatch.com/barer/${b.id}`,
+            }],
+    };
+});
+server.tool("search_matches", "Search for upcoming matches by team name, competition, or sport. Returns matches with bar counts.", {
+    query: z.string().describe("Search term — team name, competition, or sport. E.g. 'Champions League', 'Fotboll', 'Arsenal'"),
+    city: z.string().optional().describe("Optional city to filter. E.g. 'Stockholm'"),
+}, async ({ query, city }) => {
+    const blocked = rateLimitGuard();
+    if (blocked)
+        return blocked;
+    const result = searchMatches(query, city);
+    logDemand({ tool: "search_matches", team: query, city, results: result.matches.length });
+    if (result.matches.length === 0) {
+        return { content: [{ type: "text", text: `No upcoming matches found for "${query}"${city ? ` in ${city}` : ""}.` }] };
+    }
+    const lines = result.matches.map((m) => `- ${m.date_time.slice(0, 16)} | ${m.home_team} vs ${m.away_team} (${m.competition}, ${m.sport}) — ${m.bar_count} bar(s)`).join("\n");
+    return {
+        content: [{
+                type: "text",
+                text: `${result.matches.length} match(es) found:\n\n${lines}`,
+            }],
+    };
+});
+server.tool("team_schedule", "Get the upcoming schedule for a specific team, with bar counts and cities where each match is shown.", {
+    team: z.string().describe("Team name. E.g. 'Arsenal', 'Real Madrid', 'AIK'"),
+    city: z.string().optional().describe("Optional city to filter bars. E.g. 'Stockholm'"),
+}, async ({ team, city }) => {
+    const blocked = rateLimitGuard();
+    if (blocked)
+        return blocked;
+    const result = teamSchedule(team, city);
+    logDemand({ tool: "team_schedule", team, city, results: result.matches.length });
+    if (result.matches.length === 0) {
+        return { content: [{ type: "text", text: `No upcoming matches found for "${team}".` }] };
+    }
+    const lines = result.matches.map((m) => `- ${m.date_time.slice(0, 16)} | ${m.home_team} vs ${m.away_team} (${m.competition}) — ${m.bar_count} bar(s) in ${m.cities.slice(0, 5).join(", ")}`).join("\n");
+    return {
+        content: [{
+                type: "text",
+                text: `${result.matches.length} upcoming match(es) for ${team}:\n\n${lines}`,
+            }],
+    };
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("SportsBarWatch MCP server running on stdio");
+}
+main().catch(console.error);

package/dist/rate-limit.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Simple in-memory rate limiter for MCP server.
+ * Tracks queries per session with a sliding daily window.
+ * Free tier: 100 queries/day. No API key = free tier.
+ */
+export declare function checkRateLimit(sessionId: string): {
+    allowed: boolean;
+    remaining: number;
+};

package/dist/rate-limit.js

@@ -0,0 +1,29 @@
+/**
+ * Simple in-memory rate limiter for MCP server.
+ * Tracks queries per session with a sliding daily window.
+ * Free tier: 100 queries/day. No API key = free tier.
+ */
+const DAILY_LIMIT = parseInt(process.env.SBW_RATE_LIMIT || "100", 10);
+const store = new Map();
+// Clean up expired entries every 10 minutes
+setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of store) {
+        if (entry.resetAt < now)
+            store.delete(key);
+    }
+}, 10 * 60 * 1000);
+export function checkRateLimit(sessionId) {
+    const now = Date.now();
+    const dayMs = 24 * 60 * 60 * 1000;
+    const entry = store.get(sessionId);
+    if (!entry || entry.resetAt < now) {
+        store.set(sessionId, { count: 1, resetAt: now + dayMs });
+        return { allowed: true, remaining: DAILY_LIMIT - 1 };
+    }
+    entry.count++;
+    if (entry.count > DAILY_LIMIT) {
+        return { allowed: false, remaining: 0 };
+    }
+    return { allowed: true, remaining: DAILY_LIMIT - entry.count };
+}

package/dist/tools.d.ts

@@ -0,0 +1,43 @@
+export interface Bar {
+    id: string;
+    name: string;
+    address: string;
+    area: string;
+    city: string;
+    country: string;
+    phone: string | null;
+}
+interface Match {
+    id: string;
+    home_team: string;
+    away_team: string;
+    competition: string;
+    sport: string;
+    date_time: string;
+}
+export declare function findBarsShowingMatch(teamOrMatch: string, city?: string): {
+    match: Match | null;
+    bars: Bar[];
+};
+export declare function whatsOnTonight(city: string): {
+    matches: (Match & {
+        bar_count: number;
+    })[];
+};
+export declare function barDetails(barNameOrId: string): {
+    bar: Bar | null;
+    matches: Match[];
+    tags: string[];
+};
+export declare function searchMatches(query: string, city?: string): {
+    matches: (Match & {
+        bar_count: number;
+    })[];
+};
+export declare function teamSchedule(team: string, city?: string): {
+    matches: (Match & {
+        bar_count: number;
+        cities: string[];
+    })[];
+};
+export {};

package/dist/tools.js

@@ -0,0 +1,111 @@
+import { getDb } from "./db.js";
+function toPublicBar(b) {
+    return { id: b.id, name: b.name, address: b.address, area: b.area, city: b.city, country: b.country, phone: b.phone };
+}
+export function findBarsShowingMatch(teamOrMatch, city) {
+    const db = getDb();
+    const search = `%${teamOrMatch}%`;
+    // Find matching match
+    const match = db.prepare(`SELECT * FROM matches
+     WHERE (home_team LIKE ? OR away_team LIKE ? OR id LIKE ?)
+       AND date_time >= datetime('now', '-2 hours')
+     ORDER BY date_time ASC LIMIT 1`).get(search, search, search);
+    if (!match)
+        return { match: null, bars: [] };
+    let rawBars;
+    if (city) {
+        rawBars = db.prepare(`SELECT DISTINCT b.* FROM bars b
+       JOIN screenings s ON s.bar_id = b.id
+       WHERE s.match_id = ? AND b.city = ?
+       ORDER BY b.name`).all(match.id, city);
+    }
+    else {
+        rawBars = db.prepare(`SELECT DISTINCT b.* FROM bars b
+       JOIN screenings s ON s.bar_id = b.id
+       WHERE s.match_id = ?
+       ORDER BY b.name`).all(match.id);
+    }
+    return { match, bars: rawBars.map(toPublicBar) };
+}
+export function whatsOnTonight(city) {
+    const db = getDb();
+    const today = new Date().toISOString().split("T")[0];
+    const matches = db.prepare(`SELECT m.*, COUNT(DISTINCT s.bar_id) as bar_count
+     FROM matches m
+     JOIN screenings s ON s.match_id = m.id
+     JOIN bars b ON b.id = s.bar_id
+     WHERE m.date_time LIKE ? || '%'
+       AND b.city = ?
+     GROUP BY m.id
+     ORDER BY m.date_time ASC`).all(today, city);
+    return { matches };
+}
+export function barDetails(barNameOrId) {
+    const db = getDb();
+    let rawBar = db.prepare(`SELECT * FROM bars WHERE id = ?`).get(barNameOrId);
+    if (!rawBar) {
+        rawBar = db.prepare(`SELECT * FROM bars WHERE name LIKE ? LIMIT 1`).get(`%${barNameOrId}%`);
+    }
+    if (!rawBar)
+        return { bar: null, matches: [], tags: [] };
+    const bar = toPublicBar(rawBar);
+    const matches = db.prepare(`SELECT DISTINCT m.* FROM matches m
+     JOIN screenings s ON s.match_id = m.id
+     WHERE s.bar_id = ? AND m.date_time >= datetime('now', '-2 hours')
+     ORDER BY m.date_time ASC LIMIT 20`).all(rawBar.id);
+    const tagRows = db.prepare(`SELECT tag FROM bar_tags WHERE bar_id = ? ORDER BY tag`).all(rawBar.id);
+    const tags = tagRows.map(r => r.tag);
+    return { bar, matches, tags };
+}
+export function searchMatches(query, city) {
+    const db = getDb();
+    const search = `%${query}%`;
+    let sql;
+    let params;
+    if (city) {
+        sql = `SELECT m.*, COUNT(DISTINCT s.bar_id) as bar_count
+           FROM matches m
+           JOIN screenings s ON s.match_id = m.id
+           JOIN bars b ON b.id = s.bar_id
+           WHERE (m.home_team LIKE ? OR m.away_team LIKE ? OR m.competition LIKE ? OR m.sport LIKE ?)
+             AND m.date_time >= datetime('now', '-2 hours')
+             AND b.city = ?
+           GROUP BY m.id
+           ORDER BY m.date_time ASC LIMIT 20`;
+        params = [search, search, search, search, city];
+    }
+    else {
+        sql = `SELECT m.*, COUNT(DISTINCT s.bar_id) as bar_count
+           FROM matches m
+           JOIN screenings s ON s.match_id = m.id
+           WHERE (m.home_team LIKE ? OR m.away_team LIKE ? OR m.competition LIKE ? OR m.sport LIKE ?)
+             AND m.date_time >= datetime('now', '-2 hours')
+           GROUP BY m.id
+           ORDER BY m.date_time ASC LIMIT 20`;
+        params = [search, search, search, search];
+    }
+    const matches = db.prepare(sql).all(...params);
+    return { matches };
+}
+export function teamSchedule(team, city) {
+    const db = getDb();
+    const search = `%${team}%`;
+    const rawMatches = db.prepare(`SELECT m.*, COUNT(DISTINCT s.bar_id) as bar_count
+     FROM matches m
+     JOIN screenings s ON s.match_id = m.id
+     WHERE (m.home_team LIKE ? OR m.away_team LIKE ?)
+       AND m.date_time >= datetime('now', '-2 hours')
+     GROUP BY m.id
+     ORDER BY m.date_time ASC LIMIT 20`).all(search, search);
+    const matches = rawMatches.map((m) => {
+        let citiesQuery;
+        if (city) {
+            citiesQuery = db.prepare(`SELECT DISTINCT b.city FROM bars b JOIN screenings s ON s.bar_id = b.id WHERE s.match_id = ? AND b.city = ?`).all(m.id, city);
+        }
+        else {
+            citiesQuery = db.prepare(`SELECT DISTINCT b.city FROM bars b JOIN screenings s ON s.bar_id = b.id WHERE s.match_id = ?`).all(m.id);
+        }
+        return { ...m, cities: citiesQuery.map((c) => c.city) };
+    });
+    return { matches };
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@sportsbarwatch/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for SportsBarWatch — find bars showing live sports worldwide",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "sportsbarwatch-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "sports",
+    "bars",
+    "football",
+    "world-cup",
+    "live-sports",
+    "sports-bars",
+    "model-context-protocol"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eliastuff/vargarmatchen",
+    "directory": "mcp-server"
+  },
+  "homepage": "https://sportsbarwatch.com",
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "better-sqlite3": "^12.6.2",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.5.0"
+  }
+}