ikea-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 taejin5314
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Procfile

@@ -0,0 +1 @@
+web: node dist/http.js

package/README.md

@@ -0,0 +1,244 @@
+# ikea-mcp
+
+Read-only MCP server for IKEA product search and in-store stock lookup.
+
+**Transports:** stdio (Claude Desktop / MCP CLI) · Streamable HTTP (remote clients)  
+**License:** MIT · **No auth required to run locally**
+
+## Capabilities
+| Tool | What it does |
+|---|---|
+| `search_products` | Search IKEA products by keyword |
+| `check_store_stock` | Check cash-and-carry stock at one store |
+| `compare_store_stock` | Compare stock across multiple stores |
+| `find_best_store_for_item` | Rank stores by in-stock quantity |
+
+## MVP limitations
+- Uses unofficial public IKEA APIs — no SLA, may break without notice
+- ~50 confirmed US stores in catalog (`src/data/stores.ts`); some IDs remain unverified
+- Cash-and-carry availability only — click-and-collect and home delivery not exposed
+- HTTP transport has no auth — do not expose publicly without adding authentication
+- Read-only — no cart, order, or account operations
+
+## Tools
+
+### `search_products`
+
+Search IKEA products by keyword.
+
+**Input**
+| param | type | default | required |
+|---|---|---|---|
+| `query` | string | — | yes |
+| `countryCode` | string | `"us"` | no |
+| `langCode` | string | `"en"` | no |
+| `size` | number | `10` | no |
+
+**Output**
+```json
+{
+  "total": 97,
+  "items": [
+    {
+      "itemNo": "20522046",
+      "name": "BILLY",
+      "typeName": "Bookcase",
+      "salesPrice": { "amount": 69.99, "currencyCode": "USD" },
+      "pipUrl": "https://www.ikea.com/us/en/p/...",
+      "ratingValue": 4.8,
+      "ratingCount": 1234
+    }
+  ]
+}
+```
+
+---
+
+### `check_store_stock`
+
+Check stock at a single IKEA store.
+
+**Input**
+| param | type | default | required |
+|---|---|---|---|
+| `itemNo` | string | — | yes |
+| `storeId` | string | — | yes |
+| `countryCode` | string | `"us"` | no |
+
+**Output**
+```json
+{
+  "storeId": "399",
+  "availableForCashCarry": true,
+  "quantity": 110,
+  "messageType": "HIGH_IN_STOCK",
+  "errors": null
+}
+```
+
+On error (e.g. item not carried):
+```json
+{
+  "storeId": "026",
+  "availableForCashCarry": false,
+  "quantity": null,
+  "messageType": null,
+  "errors": [{ "code": 404, "message": "Not found", "meaning": "item not stocked at this store" }]
+}
+```
+
+---
+
+### `compare_store_stock`
+
+Compare stock for one item across multiple stores.
+
+**Input**
+| param | type | default | required |
+|---|---|---|---|
+| `itemNo` | string | — | yes |
+| `storeIds` | string[] (min 2) | — | yes |
+| `countryCode` | string | `"us"` | no |
+
+**Output** — array of the same shape as `check_store_stock` (one entry per store).
+
+---
+
+### `find_best_store_for_item`
+
+Find stores with the highest in-stock quantity for an item. Queries stores in parallel, excludes invalid stores (405), out-of-stock stores (404), and stores with unknown quantity. Results sorted by quantity descending; ties broken by `storeId` lexicographically.
+
+**Input**
+| param | type | default | required |
+|---|---|---|---|
+| `itemNo` | string | — | yes |
+| `storeIds` | string[] | all known stores | no |
+| `maxResults` | number | `3` (max 10) | no |
+
+**Output** — array of matching stores, up to `maxResults`:
+```json
+[
+  {
+    "storeId": "399",
+    "storeLabel": "399 (Burbank, CA)",
+    "availableForCashCarry": true,
+    "quantity": 104,
+    "messageType": "HIGH_IN_STOCK"
+  }
+]
+```
+
+Returns `[]` if no store has the item in stock. "All known stores" means the ~50 entries in `src/data/stores.ts`.
+
+---
+
+## Build and test
+
+```bash
+npm install
+npm run build        # tsc → dist/
+npm run typecheck    # type-check without emit
+npm test             # unit tests
+node smoke.mjs       # end-to-end stdio smoke test
+```
+
+`smoke.mjs` exercises all 4 tools against the live IKEA API and prints pass/fail lines to stdout.
+
+## Transports
+
+**stdio** (default — for Claude Desktop / MCP CLI):
+```bash
+node dist/index.js
+# or during dev:
+npm run dev
+```
+
+**Streamable HTTP** (for remote / network clients):
+```bash
+node dist/http.js          # listens on http://localhost:3000/mcp
+PORT=8080 node dist/http.js
+# or during dev:
+npm run dev:http
+```
+
+Requests must include `Accept: application/json, text/event-stream`. Stateless — no session management.
+
+## Deploy (HTTP transport)
+
+Tested target: **Railway** (also works on Render, Heroku, or any Procfile-aware host).
+
+```bash
+# 1. build
+npm install && npm run build
+
+# 2. run (Procfile: web: node dist/http.js)
+#    PORT is set automatically by the host
+node dist/http.js
+```
+
+The `Procfile` in the repo root declares `web: node dist/http.js`. `PORT` is read from the environment (default `3000`). No other env vars required.
+
+Endpoints after deploy:
+- `POST /mcp` — MCP Streamable HTTP (requires `Accept: application/json, text/event-stream`)
+- `GET /health` — returns `{"status":"ok"}`
+
+> **Security note:** No auth is implemented in this MVP. Do not expose the `/mcp` endpoint publicly without adding authentication. The server is read-only — no cart, order, or account operations are possible.
+
+## Connecting a remote MCP client
+
+Point your MCP client at `https://<your-host>/mcp`.
+
+**Claude Desktop** (`claude_desktop_config.json`):
+```json
+{
+  "mcpServers": {
+    "ikea-mcp": {
+      "type": "http",
+      "url": "https://<your-host>/mcp"
+    }
+  }
+}
+```
+
+**`.mcp.json`** (project-local, Claude Code):
+```json
+{
+  "mcpServers": {
+    "ikea-mcp": {
+      "type": "http",
+      "url": "https://<your-host>/mcp"
+    }
+  }
+}
+```
+
+**Manual / curl** (for debugging):
+```bash
+curl -X POST https://<your-host>/mcp \
+  -H "Content-Type: application/json" \
+  -H "Accept: application/json, text/event-stream" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
+```
+
+The `Accept: application/json, text/event-stream` header is required by the MCP SDK — requests without it will be rejected with a `-32000` error.
+
+## Store IDs
+
+Store metadata (ID → city label) lives in `src/data/stores.ts`. ~50 US stores are confirmed from `ikea.com/us/en/stores/<slug>/` pages.
+
+Confirmed compatible `storeId` formats:
+- Standard 3-digit: `"399"` (Burbank, CA)
+- Leading-zero 3-digit: `"026"` (Canton, MI), `"042"` (Tampa, FL)
+- 4-digit: `"921"` (Brooklyn, NY), `"1129"` (Syracuse, NY)
+
+Some stores remain unconfirmed (no store page ID found or not yet probed). A few valid-looking IDs from the stock API have no known city mapping — see TODO comments in `stores.ts`.
+
+An invalid or unsupported `storeId` returns a 405 error in the `errors` array.
+
+## Limitations
+
+- Uses unofficial public IKEA APIs — no SLA, no auth required, may break without notice.
+- Read-only: no cart, no order, no account operations.
+- `compare_store_stock` fires all store requests in parallel — large `storeIds` arrays may hit rate limits.
+- Click-and-collect and home-delivery availability are not exposed (cash-and-carry only).
+- `size` in `search_products` is capped by IKEA's API (observed max ~24 per page; `total` reflects the full catalogue count).

package/dist/data/stores.js

@@ -0,0 +1,63 @@
+// US store labels confirmed from ikea.com/us/en/stores/<slug>/ pages (store_id= survey param).
+// IDs match the sto/{storeId} path used by the IKEA stock API.
+// 4-digit IDs (921, 1099, 1129) are newer-format stores — confirmed working with stock API.
+// 3136 (San Francisco) returns 405 from stock API — excluded.
+// TODO: huntsville, arcadia, mcallen-pharr, san-marcos — IDs not found on store pages.
+// TODO: 313, 372, 414, 448, 529, 559, 612, 634, 652, 661, 663, 692, 693 — valid API IDs, city unknown (possibly CA/other).
+export const STORE_LABELS = {
+    "026": "026 (Canton, MI)",
+    "027": "027 (Round Rock, TX)",
+    "028": "028 (Portland, OR)",
+    "042": "042 (Tampa, FL)",
+    "064": "064 (Centennial, CO)",
+    "067": "067 (Charlotte, NC)",
+    "103": "103 (Draper, UT)",
+    "145": "145 (Orlando, FL)",
+    "152": "152 (Baltimore, MD)",
+    "153": "153 (Pittsburgh, PA)",
+    "154": "154 (Elizabeth, NJ)",
+    "156": "156 (Long Island, NY)",
+    "157": "157 (West Sacramento, CA)",
+    "158": "158 (Stoughton, MA)",
+    "162": "162 (Carson, CA)",
+    "165": "165 (Emeryville, CA)",
+    "166": "166 (San Diego, CA)",
+    "167": "167 (Costa Mesa, CA)",
+    "168": "168 (Woodbridge, VA)",
+    "170": "170 (Bolingbrook, IL)",
+    "175": "175 (West Chester, OH)",
+    "183": "183 (Frisco, TX)",
+    "207": "207 (Sunrise, FL)",
+    "209": "209 (Tempe, AZ)",
+    "210": "210 (Schaumburg, IL)",
+    "211": "211 (Conshohocken, PA)",
+    "212": "212 (Minneapolis, MN)",
+    "213": "213 (New Haven, CT)",
+    "215": "215 (South Philadelphia, PA)",
+    "257": "257 (Atlanta, GA)",
+    "327": "327 (Miami, FL)",
+    "347": "347 (East Palo Alto, CA)",
+    "374": "374 (Merriam, KS)",
+    "379": "379 (Houston, TX)",
+    "399": "399 (Burbank, CA)",
+    "409": "409 (Paramus, NJ)",
+    "410": "410 (St. Louis, MO)",
+    "411": "411 (College Park, MD)",
+    "413": "413 (Covina, CA)",
+    "462": "462 (Las Vegas, NV)",
+    "488": "488 (Renton, WA)",
+    "508": "508 (Memphis, TN)",
+    "511": "511 (Columbus, OH)",
+    "535": "535 (Grand Prairie, TX)",
+    "536": "536 (Fishers, IN)",
+    "537": "537 (Jacksonville, FL)",
+    "560": "560 (Oak Creek, WI)",
+    "569": "569 (Norfolk, VA)",
+    "570": "570 (Live Oak, TX)",
+    "921": "921 (Brooklyn, NY)",
+    "1099": "1099 (University Park, TX)",
+    "1129": "1129 (Syracuse, NY)",
+};
+export function storeLabel(storeId) {
+    return STORE_LABELS[storeId];
+}

package/dist/http.js

@@ -0,0 +1,63 @@
+import { createServer as createHttpServer } from "node:http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer } from "./server.js";
+const PORT = Number(process.env.PORT ?? 3000);
+const BODY_LIMIT = 1024 * 1024; // 1 MB
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let raw = "";
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > BODY_LIMIT) {
+                reject(new Error("request body too large"));
+                req.destroy();
+                return;
+            }
+            raw += chunk.toString();
+        });
+        req.on("end", () => {
+            try {
+                resolve(raw ? JSON.parse(raw) : undefined);
+            }
+            catch {
+                reject(new Error("invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, { "Content-Type": "application/json" }).end(payload);
+}
+const httpServer = createHttpServer(async (req, res) => {
+    const method = req.method ?? "";
+    const url = req.url ?? "";
+    console.error(`${new Date().toISOString()} ${method} ${url}`);
+    try {
+        if (url === "/health") {
+            sendJson(res, 200, { status: "ok" });
+            return;
+        }
+        if (method === "POST" && url === "/mcp") {
+            const body = await readBody(req);
+            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+            await createServer().connect(transport);
+            await transport.handleRequest(req, res, body);
+            return;
+        }
+        res.writeHead(404).end("Not found");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "internal error";
+        console.error(`ERROR ${method} ${url}:`, message);
+        if (!res.headersSent) {
+            sendJson(res, 500, { error: message });
+        }
+    }
+});
+httpServer.listen(PORT, () => {
+    console.error(`ikea-mcp HTTP listening on http://localhost:${PORT}/mcp`);
+    console.error(`health: http://localhost:${PORT}/health`);
+});

package/dist/index.js

@@ -0,0 +1,4 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+const transport = new StdioServerTransport();
+await createServer().connect(transport);

package/dist/schemas/index.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export const SearchProductsInput = z.object({
+    query: z.string().min(1),
+    countryCode: z.string().length(2).default("us"),
+    langCode: z.string().length(2).default("en"),
+    size: z.number().int().min(1).max(50).default(10),
+});
+export const CheckStoreStockInput = z.object({
+    itemNo: z.string().min(1),
+    storeId: z.string().min(1),
+    countryCode: z.string().length(2).default("us"),
+});
+export const CompareStoreStockInput = z.object({
+    itemNo: z.string().min(1),
+    storeIds: z.array(z.string().min(1)).min(2).max(10),
+    countryCode: z.string().length(2).default("us"),
+});
+export const FindBestStoreInput = z.object({
+    itemNo: z.string().min(1),
+    storeIds: z.array(z.string().min(1)).optional(),
+    maxResults: z.number().int().min(1).max(10).default(3),
+});

package/dist/server.js

@@ -0,0 +1,25 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { searchProductsTool } from "./tools/search_products.js";
+import { checkStoreStockTool } from "./tools/check_store_stock.js";
+import { compareStoreStockTool } from "./tools/compare_store_stock.js";
+import { findBestStoreForItemTool } from "./tools/find_best_store_for_item.js";
+const tools = [searchProductsTool, checkStoreStockTool, compareStoreStockTool, findBestStoreForItemTool];
+export function createServer() {
+    const server = new Server({ name: "ikea-mcp", version: "1.0.0" }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: tools.map(({ name, description, inputSchema }) => ({
+            name,
+            description,
+            inputSchema,
+        })),
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        const tool = tools.find((t) => t.name === req.params.name);
+        if (!tool) {
+            throw new Error(`Unknown tool: ${req.params.name}`);
+        }
+        return tool.handler(req.params.arguments);
+    });
+    return server;
+}

package/dist/services/ikea.js

@@ -0,0 +1,40 @@
+import { fetchJson } from "../utils/http.js";
+const SEARCH_BASE = "https://sik.search.blue.cdtapps.com";
+const STOCK_BASE = "https://api.ingka.ikea.com/cia/availabilities";
+// Confirmed public client ID (no secret required)
+const STOCK_CLIENT_ID = "b6c117e5-ae61-4ef5-b4cc-e0b1e37f0631";
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function annotateStockErrors(errors) {
+    return errors?.map((e) => ({
+        ...e,
+        meaning: e.code === 404 ? "item not stocked at this store" : e.code === 405 ? "store ID does not exist" : "unknown",
+    }));
+}
+export function projectStock(result) {
+    const a = result.availabilities?.[0];
+    return {
+        availableForCashCarry: a?.availableForCashCarry ?? false,
+        quantity: a?.buyingOption.cashCarry.availability.quantity ?? null,
+        messageType: a?.buyingOption.cashCarry.availability.probability.thisDay.messageType ?? null,
+        errors: annotateStockErrors(result.errors) ?? [],
+    };
+}
+// ── Service functions ─────────────────────────────────────────────────────────
+export async function searchProducts(query, countryCode, langCode, size) {
+    // Correct endpoint: /search-result-page (not /search — returns 404)
+    const url = `${SEARCH_BASE}/${countryCode}/${langCode}/search-result-page` +
+        `?q=${encodeURIComponent(query)}&size=${size}`;
+    return fetchJson(url, {
+        "User-Agent": "Mozilla/5.0",
+    });
+}
+export async function getStoreStock(itemNo, storeId, 
+// countryCode unused: endpoint path is /sto/{storeId}, country is implicit in storeId
+_countryCode) {
+    // classUnitType must be "sto" (not country code); "ru" exists but storeId maps to "sto"
+    const url = `${STOCK_BASE}/sto/${storeId}` +
+        `?itemNos=${encodeURIComponent(itemNo)}&expand=StoresList,Restocks`;
+    return fetchJson(url, {
+        "X-Client-Id": STOCK_CLIENT_ID,
+    });
+}

package/dist/tools/check_store_stock.js

@@ -0,0 +1,27 @@
+import { CheckStoreStockInput } from "../schemas/index.js";
+import { getStoreStock, projectStock } from "../services/ikea.js";
+import { storeLabel } from "../data/stores.js";
+export const checkStoreStockTool = {
+    name: "check_store_stock",
+    description: "Check stock availability for an item at a specific IKEA store.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            itemNo: { type: "string" },
+            storeId: { type: "string" },
+            countryCode: { type: "string", default: "us" },
+        },
+        required: ["itemNo", "storeId"],
+    },
+    async handler(rawInput) {
+        const input = CheckStoreStockInput.parse(rawInput);
+        const result = await getStoreStock(input.itemNo, input.storeId, input.countryCode);
+        const label = storeLabel(input.storeId);
+        const output = {
+            storeId: input.storeId,
+            ...(label ? { storeLabel: label } : {}),
+            ...projectStock(result),
+        };
+        return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    },
+};

package/dist/tools/compare_store_stock.js

@@ -0,0 +1,28 @@
+import { CompareStoreStockInput } from "../schemas/index.js";
+import { getStoreStock, projectStock } from "../services/ikea.js";
+import { storeLabel } from "../data/stores.js";
+export const compareStoreStockTool = {
+    name: "compare_store_stock",
+    description: "Compare stock availability for an item across multiple IKEA stores.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            itemNo: { type: "string" },
+            storeIds: { type: "array", items: { type: "string" }, minItems: 2 },
+            countryCode: { type: "string", default: "us" },
+        },
+        required: ["itemNo", "storeIds"],
+    },
+    async handler(rawInput) {
+        const input = CompareStoreStockInput.parse(rawInput);
+        const results = await Promise.all(input.storeIds.map((storeId) => getStoreStock(input.itemNo, storeId, input.countryCode).then((data) => {
+            const label = storeLabel(storeId);
+            return {
+                storeId,
+                ...(label ? { storeLabel: label } : {}),
+                ...projectStock(data),
+            };
+        })));
+        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+    },
+};

package/dist/tools/find_best_store_for_item.js

@@ -0,0 +1,43 @@
+import { FindBestStoreInput } from "../schemas/index.js";
+import { getStoreStock, projectStock } from "../services/ikea.js";
+import { STORE_LABELS, storeLabel } from "../data/stores.js";
+export const findBestStoreForItemTool = {
+    name: "find_best_store_for_item",
+    description: "Find stores with the highest in-stock quantity for an item. Returns up to maxResults stores sorted by quantity descending.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            itemNo: { type: "string" },
+            storeIds: { type: "array", items: { type: "string" } },
+            maxResults: { type: "number", default: 3 },
+        },
+        required: ["itemNo"],
+    },
+    async handler(rawInput) {
+        const input = FindBestStoreInput.parse(rawInput);
+        const targetIds = input.storeIds ?? Object.keys(STORE_LABELS);
+        const results = await Promise.all(targetIds.map(async (storeId) => {
+            const data = await getStoreStock(input.itemNo, storeId, "us");
+            const stock = projectStock(data);
+            return { storeId, stock };
+        }));
+        const ranked = results
+            .filter((r) => r.stock.availableForCashCarry && r.stock.quantity !== null)
+            .sort((a, b) => {
+            const diff = (b.stock.quantity ?? 0) - (a.stock.quantity ?? 0);
+            return diff !== 0 ? diff : a.storeId.localeCompare(b.storeId);
+        })
+            .slice(0, input.maxResults)
+            .map(({ storeId, stock }) => {
+            const label = storeLabel(storeId);
+            return {
+                storeId,
+                ...(label ? { storeLabel: label } : {}),
+                availableForCashCarry: stock.availableForCashCarry,
+                quantity: stock.quantity,
+                messageType: stock.messageType,
+            };
+        });
+        return { content: [{ type: "text", text: JSON.stringify(ranked, null, 2) }] };
+    },
+};

package/dist/tools/search_products.js

@@ -0,0 +1,34 @@
+import { SearchProductsInput } from "../schemas/index.js";
+import { searchProducts } from "../services/ikea.js";
+export const searchProductsTool = {
+    name: "search_products",
+    description: "Search IKEA products by keyword.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: { type: "string" },
+            countryCode: { type: "string", default: "us" },
+            langCode: { type: "string", default: "en" },
+            size: { type: "number", default: 10 },
+        },
+        required: ["query"],
+    },
+    async handler(rawInput) {
+        const input = SearchProductsInput.parse(rawInput);
+        const result = await searchProducts(input.query, input.countryCode, input.langCode, input.size);
+        const main = result.searchResultPage.products.main;
+        const output = {
+            total: main.max,
+            items: main.items.filter((i) => i.product != null).map(({ product: p }) => ({
+                itemNo: p.itemNo,
+                name: p.name,
+                typeName: p.typeName,
+                salesPrice: { amount: p.salesPrice.numeral, currencyCode: p.salesPrice.currencyCode },
+                pipUrl: p.pipUrl,
+                ratingValue: p.ratingValue,
+                ratingCount: p.ratingCount,
+            })),
+        };
+        return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    },
+};

package/dist/utils/http.js

@@ -0,0 +1,12 @@
+export async function fetchJson(url, headers) {
+    const res = await fetch(url, {
+        headers: {
+            Accept: "application/json",
+            ...headers,
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`HTTP ${res.status} ${res.statusText}: ${url}`);
+    }
+    return res.json();
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "ikea-mcp",
+  "version": "1.0.0",
+  "description": "Read-only MCP server for IKEA product search and in-store stock lookup. Supports stdio and Streamable HTTP transports.",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "files": [
+    "dist/",
+    "Procfile"
+  ],
+  "keywords": [
+    "mcp",
+    "ikea",
+    "model-context-protocol",
+    "stock",
+    "inventory"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/taejin5314/ikea-mcp.git"
+  },
+  "homepage": "https://github.com/taejin5314/ikea-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/taejin5314/ikea-mcp/issues"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "dev:http": "tsx src/http.ts",
+    "start": "node dist/index.js",
+    "start:http": "node dist/http.js",
+    "smoke": "node smoke.mjs",
+    "smoke:http": "node smoke-http.mjs",
+    "test": "node --import tsx/esm --test test/unit.test.ts",
+    "typecheck": "tsc -p tsconfig.test.json"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  }
+}