@bojanrajkovic/mcp-paprika 1.0.4 → 1.1.0

package/README.md

@@ -4,14 +4,30 @@ An [MCP](https://modelcontextprotocol.io/) server for [Paprika](https://www.papr
 
 ## Features
 
-- **10 tools** for recipe management — search, filter, CRUD, categories, pagination
+- **14 tools** for recipe and pantry management — search, filter, CRUD, categories, pagination, pantry inventory
 - **Semantic search** via `discover_recipes` — find recipes by natural language description using any OpenAI-compatible embedding provider
 - **Background sync** — keeps your local cache in sync with Paprika's cloud
-- **MCP resources** — expose recipes as `paprika://recipe/{uid}` resources
+- **MCP resources** — expose recipes as `paprika://recipe/{uid}` and pantry items as `paprika://pantry/{uid}` resources
+- **Two transports** — stdio (default, for CLI clients) and Streamable HTTP (for mobile/web clients)
+- **Container image** — `Dockerfile` ships a distroless runtime ready for self-hosting
 
-## Quick start
+## Transports
 
-Add to your MCP client config (e.g. Claude Desktop):
+`mcp-paprika` can speak the MCP protocol over two transports, selected via `MCP_TRANSPORT`:
+
+| Transport | Default? | Use it for                                                                          |
+| --------- | -------- | ----------------------------------------------------------------------------------- |
+| `stdio`   | yes      | Local CLI clients: Claude Code, Claude Desktop, Cursor, mcp-cli                     |
+| `http`    | no       | Streamable HTTP for Claude Mobile and other HTTP-based MCP clients, or self-hosting |
+
+> **HTTP transport has no built-in authentication.** Do not expose port 3000 directly
+> to the public internet. Put it behind Cloudflare Access, Tailscale Serve, an OAuth2
+> proxy, or your reverse proxy of choice. OAuth 2.1 support is planned as a follow-up
+> — until then, network-trust is the supported deployment model.
+
+## Quick start — stdio (Claude Desktop / Claude Code / Cursor)
+
+Add to your MCP client config:
 
 ```json
 {
@@ -28,14 +44,94 @@ Add to your MCP client config (e.g. Claude Desktop):
 }
 ```
 
-See [configuration](docs/configuration.md) for all available options including background sync and semantic search.
+## Quick start — HTTP transport
+
+Run with env vars set:
+
+```bash
+MCP_TRANSPORT=http \
+MCP_HTTP_PORT=3000 \
+PAPRIKA_EMAIL=you@example.com \
+PAPRIKA_PASSWORD=your-password \
+  npx -y @bojanrajkovic/mcp-paprika
+```
+
+The server then exposes:
+
+- `POST /mcp` — MCP JSON-RPC over Streamable HTTP (single endpoint that multiplexes initialize, tools/list, tools/call, etc.)
+- `GET  /mcp` — long-lived SSE channel for server→client notifications (resource list changed, log messages)
+- `DELETE /mcp` — session termination
+- `GET /healthz` — liveness probe returning `{ "ok": true, "sessions": <n> }`
+
+Verify locally:
+
+```bash
+curl -sf http://127.0.0.1:3000/healthz
+# → {"ok":true,"sessions":0}
+```
+
+## Quick start — container
+
+```bash
+docker build -t mcp-paprika:dev .
+
+docker run --rm \
+  -e PAPRIKA_EMAIL=you@example.com \
+  -e PAPRIKA_PASSWORD=your-password \
+  -v "$(pwd)/data:/data" \
+  -p 3000:3000 \
+  mcp-paprika:dev
+```
+
+The image defaults to `MCP_TRANSPORT=http`, binds on `0.0.0.0:3000`, and persists the
+disk cache and vector index under `/data` (the documented mount point). Both `/data`
+sub-directories (`config/`, `cache/`) are pre-created with `nonroot` (UID 65532)
+ownership in the image so writes work the first time even on a fresh bind-mount.
+
+If you bind-mount a host directory you created as root, pre-chown it:
+
+```bash
+mkdir -p ./data && sudo chown -R 65532:65532 ./data
+```
+
+Or use a named volume (Docker handles ownership automatically):
+
+```bash
+docker run --rm \
+  -e PAPRIKA_EMAIL=... -e PAPRIKA_PASSWORD=... \
+  -v mcp-paprika-data:/data \
+  -p 3000:3000 \
+  mcp-paprika:dev
+```
+
+The image also declares a `HEALTHCHECK` that hits `GET /healthz`; verify with:
+
+```bash
+docker inspect --format '{{.State.Health.Status}}' <container>
+# → healthy
+```
+
+## Deployment patterns (HTTP transport)
+
+Because the HTTP transport ships without authentication, the supported deployment is
+"behind a network-trust boundary." Some good options:
+
+- **Cloudflare Tunnel + Cloudflare Access** (recommended for public reachability) — a
+  zero-trust front door with SSO/IdP integration, no inbound ports exposed.
+- **Tailscale Serve** — exposes the container only over your tailnet; perfect for
+  homelab / single-user setups.
+- **OAuth2 proxy** (e.g. [oauth2-proxy](https://github.com/oauth2-proxy/oauth2-proxy))
+  in front of the container.
+- **Reverse proxy basic-auth** (nginx / Caddy `basic_auth`) for the simplest setup
+  when you really just need a password gate.
 
 ## Documentation
 
-- **[Configuration](docs/configuration.md)** — env vars, config files, platform paths
-- **[Tools reference](docs/tools/)** — all 10 tools with parameters and examples
+- **[Configuration](docs/configuration.md)** — env vars, config files, transport options, platform paths
+- **[Tools reference](docs/tools/)** — every tool with parameters and examples
 - **[Embedding providers](docs/embedding-providers.md)** — set up semantic search with Ollama, OpenAI, OpenRouter, etc.
 - **[Architecture](docs/architecture.md)** — how it works under the hood
+- **[Verified MCP SDK API](docs/verified-api.md)** — the authoritative reference for SDK import paths and the Streamable HTTP wiring
 
 ## License
 

package/dist/cache/disk-cache.d.ts

@@ -1,19 +1,24 @@
-import type { Recipe, Category, RecipeEntry, DiffResult } from "../paprika/types.js";
+import type { Recipe, Category, RecipeEntry, DiffResult, PantryItem } from "../paprika/types.js";
 export declare class DiskCache {
     private readonly _cacheDir;
     private readonly _indexPath;
     private readonly _recipesDir;
     private readonly _categoriesDir;
+    private readonly _pantryDir;
     private _index;
     private readonly _pendingRecipes;
     private readonly _pendingCategories;
+    private readonly _pendingPantryItems;
     constructor(cacheDir: string);
     init(): Promise<void>;
     flush(): Promise<void>;
     getRecipe(uid: string): Promise<Recipe | null>;
     putRecipe(recipe: Recipe, hash: string): void;
+    putPantryItem(item: PantryItem): void;
     removeRecipe(uid: string): Promise<void>;
+    removePantryItem(uid: string): Promise<void>;
     getAllRecipes(): Promise<Array<Recipe>>;
+    getAllPantryItems(): Promise<Array<PantryItem>>;
     getCategory(uid: string): Promise<Category | null>;
     putCategory(category: Category, hash: string): void;
     private _diffEntries;

package/dist/cache/disk-cache.js

@@ -1,7 +1,7 @@
 import { mkdir, open, readFile, readdir, rename, unlink } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
-import { RecipeStoredSchema, CategoryStoredSchema } from "../paprika/types.js";
+import { RecipeStoredSchema, CategoryStoredSchema, PantryItemStoredSchema } from "../paprika/types.js";
 // Type guard for NodeJS.ErrnoException. Mirrors the local helper in
 // utils/config.ts but is intentionally not exported from there — each
 // module defines its own copy per the existing pattern.
@@ -19,12 +19,14 @@ function isNodeError(error) {
 const CacheIndexSchema = z.object({
     recipes: z.record(z.string(), z.string()),
     categories: z.record(z.string(), z.string()),
+    pantry: z.record(z.string(), z.string()).default({}),
 });
 export class DiskCache {
     _cacheDir;
     _indexPath;
     _recipesDir;
     _categoriesDir;
+    _pantryDir;
     // Null until init() is called. diff*() and flush() assert non-null.
     _index = null;
     // Pending writes buffered by put*(). Drained by flush(). get*() checks
@@ -32,16 +34,19 @@ export class DiskCache {
     // they just put in the same sync cycle.
     _pendingRecipes = new Map();
     _pendingCategories = new Map();
+    _pendingPantryItems = new Map();
     constructor(cacheDir) {
         this._cacheDir = cacheDir;
         this._indexPath = join(cacheDir, "index.json");
         this._recipesDir = join(cacheDir, "recipes");
         this._categoriesDir = join(cacheDir, "categories");
+        this._pantryDir = join(cacheDir, "pantry");
     }
     async init() {
         // Create subdirectories (idempotent — recursive: true).
         await mkdir(this._recipesDir, { recursive: true });
         await mkdir(this._categoriesDir, { recursive: true });
+        await mkdir(this._pantryDir, { recursive: true });
         // Load index.json. ENOENT = first run → empty index.
         // Parse failure = corruption → log warning + empty index.
         // Other I/O error → rethrow.
@@ -51,7 +56,7 @@ export class DiskCache {
         }
         catch (error) {
             if (isNodeError(error) && error.code === "ENOENT") {
-                this._index = { recipes: {}, categories: {} };
+                this._index = { recipes: {}, categories: {}, pantry: {} };
                 return;
             }
             throw error;
@@ -62,13 +67,13 @@ export class DiskCache {
         }
         catch {
             process.stderr.write("DiskCache: corrupt index.json (invalid JSON), resetting to empty index\n");
-            this._index = { recipes: {}, categories: {} };
+            this._index = { recipes: {}, categories: {}, pantry: {} };
             return;
         }
         const result = CacheIndexSchema.safeParse(parsed);
         if (!result.success) {
             process.stderr.write("DiskCache: corrupt index.json (schema mismatch), resetting to empty index\n");
-            this._index = { recipes: {}, categories: {} };
+            this._index = { recipes: {}, categories: {}, pantry: {} };
             return;
         }
         this._index = result.data;
@@ -104,6 +109,17 @@ export class DiskCache {
                     await fh.close();
                 }
             }),
+            ...[...this._pendingPantryItems.entries()].map(async ([uid, item]) => {
+                const filePath = join(this._pantryDir, `${uid}.json`);
+                const fh = await open(filePath, "w");
+                try {
+                    await fh.writeFile(JSON.stringify(item, null, 2));
+                    await fh.sync();
+                }
+                finally {
+                    await fh.close();
+                }
+            }),
         ]);
         // Write index atomically via temp-then-rename.
         // The tmp file is written to cacheDir (same filesystem as index.json)
@@ -120,6 +136,7 @@ export class DiskCache {
         await rename(tmpPath, this._indexPath);
         this._pendingRecipes.clear();
         this._pendingCategories.clear();
+        this._pendingPantryItems.clear();
     }
     async getRecipe(uid) {
         // Pending map is checked first so callers can read back data they just
@@ -151,6 +168,13 @@ export class DiskCache {
         // without requiring flush() first (AC6.1).
         this._index.recipes[recipe.uid] = hash;
     }
+    putPantryItem(item) {
+        if (this._index === null) {
+            throw new Error("DiskCache: putPantryItem() called before init()");
+        }
+        this._pendingPantryItems.set(item.uid, item);
+        this._index.pantry[item.uid] = "";
+    }
     async removeRecipe(uid) {
         if (this._index === null) {
             throw new Error("DiskCache: removeRecipe() called before init()");
@@ -169,6 +193,22 @@ export class DiskCache {
         delete this._index.recipes[uid];
         this._pendingRecipes.delete(uid);
     }
+    async removePantryItem(uid) {
+        if (this._index === null) {
+            throw new Error("DiskCache: removePantryItem() called before init()");
+        }
+        const filePath = join(this._pantryDir, `${uid}.json`);
+        try {
+            await unlink(filePath);
+        }
+        catch (error) {
+            if (!isNodeError(error) || error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        delete this._index.pantry[uid];
+        this._pendingPantryItems.delete(uid);
+    }
     async getAllRecipes() {
         if (this._index === null) {
             throw new Error("DiskCache: getAllRecipes() called before init()");
@@ -197,6 +237,32 @@ export class DiskCache {
         }));
         return [...result.values()];
     }
+    async getAllPantryItems() {
+        if (this._index === null) {
+            throw new Error("DiskCache: getAllPantryItems() called before init()");
+        }
+        const result = new Map(this._pendingPantryItems);
+        let files;
+        try {
+            files = await readdir(this._pantryDir);
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT") {
+                return [...result.values()];
+            }
+            throw error;
+        }
+        const jsonFiles = files.filter((f) => f.endsWith(".json"));
+        await Promise.all(jsonFiles.map(async (filename) => {
+            const uid = filename.slice(0, -5);
+            if (result.has(uid))
+                return;
+            const raw = await readFile(join(this._pantryDir, filename), "utf-8");
+            const item = PantryItemStoredSchema.parse(JSON.parse(raw));
+            result.set(uid, item);
+        }));
+        return [...result.values()];
+    }
     async getCategory(uid) {
         const pending = this._pendingCategories.get(uid);
         if (pending !== undefined) {

package/dist/cache/pantry-store.d.ts

@@ -0,0 +1,20 @@
+import type { PantryItem, PantryItemUid } from "../paprika/types.js";
+export declare class PantryStore {
+    private readonly _items;
+    private readonly _tombstones;
+    private _hasSynced;
+    load(items: ReadonlyArray<PantryItem>): void;
+    get(uid: PantryItemUid): PantryItem | undefined;
+    getAll(): Array<PantryItem>;
+    set(item: PantryItem): void;
+    delete(uid: PantryItemUid): void;
+    /**
+     * Returns true if `uid` was soft-deleted via this store in the current
+     * session (since the last `load()`). Used by `delete_pantry_item` to give
+     * idempotent retried-delete callers a clear "already deleted" signal.
+     */
+    isTombstone(uid: PantryItemUid): boolean;
+    get size(): number;
+    get hasSynced(): boolean;
+    findByIngredient(query: string): Array<PantryItem>;
+}

package/dist/cache/pantry-store.js

@@ -0,0 +1,81 @@
+export class PantryStore {
+    _items = new Map();
+    // Tombstones track UIDs that were soft-deleted via this client, so
+    // `delete_pantry_item` can return a distinct "already deleted" message for
+    // retried calls (server upserts by UID and the live-items map alone can't
+    // distinguish "I deleted this" from "this never existed"). Tombstones
+    // persist across `load()` so delayed retries that span a sync cycle still
+    // get the idempotent signal — `load()` only un-tombstones UIDs that are
+    // now back in the live items list (i.e. resurrected by the server, e.g.,
+    // un-deleted via another client). The tombstone set therefore stays
+    // disjoint from `_items` after every load.
+    _tombstones = new Set();
+    _hasSynced = false;
+    load(items) {
+        this._items.clear();
+        for (const item of items) {
+            this._items.set(item.uid, item);
+            // Resurrection: if this UID was previously tombstoned, the new live
+            // entry supersedes the tombstone (item came back from the server).
+            this._tombstones.delete(item.uid);
+        }
+        this._hasSynced = true;
+    }
+    get(uid) {
+        return this._items.get(uid);
+    }
+    getAll() {
+        return [...this._items.values()];
+    }
+    set(item) {
+        this._items.set(item.uid, item);
+        this._tombstones.delete(item.uid);
+    }
+    delete(uid) {
+        // Always tombstone, regardless of whether `uid` is currently in `_items`.
+        // The only caller is `commitPantryItem`'s delete branch (post-successful
+        // savePantryItem), but several awaits separate the save from the local
+        // commit; SyncEngine.syncOnce() can interleave a `load(...)` that wipes
+        // the UID from `_items` before commit lands. Conditioning the tombstone
+        // on `_items.has(uid)` would silently drop the idempotent retry signal
+        // in exactly that race. Spurious tombstones from other callers are
+        // acceptable: an extra "already deleted" message is harmless; a missing
+        // one isn't.
+        this._tombstones.add(uid);
+        this._items.delete(uid);
+    }
+    /**
+     * Returns true if `uid` was soft-deleted via this store in the current
+     * session (since the last `load()`). Used by `delete_pantry_item` to give
+     * idempotent retried-delete callers a clear "already deleted" signal.
+     */
+    isTombstone(uid) {
+        return this._tombstones.has(uid);
+    }
+    get size() {
+        return this._items.size;
+    }
+    get hasSynced() {
+        return this._hasSynced;
+    }
+    findByIngredient(query) {
+        const needle = query.toLowerCase();
+        const exact = [];
+        const prefix = [];
+        const substring = [];
+        for (const item of this._items.values()) {
+            const hay = item.ingredient.toLowerCase();
+            if (hay === needle)
+                exact.push(item);
+            else if (hay.startsWith(needle))
+                prefix.push(item);
+            else if (hay.includes(needle))
+                substring.push(item);
+        }
+        if (exact.length > 0)
+            return exact;
+        if (prefix.length > 0)
+            return prefix;
+        return substring;
+    }
+}

package/dist/features/discover-feature.d.ts

@@ -1,5 +1,29 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ServerContext } from "../types/server-context.js";
-import type { SyncEngine } from "../paprika/sync.js";
+import { VectorStore } from "./vector-store.js";
+import type { RecipeStore } from "../cache/recipe-store.js";
+import type { SyncResult } from "../paprika/types.js";
 import type { PaprikaConfig } from "../utils/config.js";
-export declare function setupDiscoverFeature(server: McpServer, ctx: ServerContext, sync: SyncEngine, config: PaprikaConfig): Promise<void>;
+/**
+ * View over the SyncEngine event stream. Matches `SyncEngine.events` (a
+ * `Pick<SyncEventEmitter, "on" | "off">`). Declared locally to avoid
+ * pulling a hard dependency on `SyncEngine` itself.
+ */
+export interface SyncEventsView {
+    on(event: "sync:complete", handler: (data: SyncResult) => void): void;
+    on(event: "sync:error", handler: (data: Error) => void): void;
+    off(event: "sync:complete", handler?: (data: SyncResult) => void): void;
+    off(event: "sync:error", handler?: (data: Error) => void): void;
+}
+/**
+ * Build the process-wide semantic-search components.
+ *
+ * - Returns `null` and logs "Semantic search: disabled" when embeddings are
+ *   not configured. Callers should skip discover tool registration in that case.
+ * - Otherwise: instantiates the embedding client + vector store, performs
+ *   cold-start indexing if the vector store is missing entries relative to
+ *   the recipe store, and subscribes to `syncEvents.on("sync:complete", …)`
+ *   for incremental re-indexing.
+ *
+ * Tool registration is intentionally NOT done here — `buildMcpServer` calls
+ * `registerDiscoverTool(server, sessionCtx, vectorStore)` per session.
+ */
+export declare function buildDiscoverComponents(config: PaprikaConfig, store: RecipeStore, syncEvents: SyncEventsView): Promise<VectorStore | null>;

package/dist/features/discover-feature.js

@@ -1,34 +1,45 @@
 import { EmbeddingClient, EMBEDDING_SCHEMA_VERSION } from "./embeddings.js";
 import { VectorStore } from "./vector-store.js";
-import { registerDiscoverTool } from "../tools/discover.js";
 import { getCacheDir } from "../utils/xdg.js";
-export async function setupDiscoverFeature(server, ctx, sync, config) {
+/**
+ * Build the process-wide semantic-search components.
+ *
+ * - Returns `null` and logs "Semantic search: disabled" when embeddings are
+ *   not configured. Callers should skip discover tool registration in that case.
+ * - Otherwise: instantiates the embedding client + vector store, performs
+ *   cold-start indexing if the vector store is missing entries relative to
+ *   the recipe store, and subscribes to `syncEvents.on("sync:complete", …)`
+ *   for incremental re-indexing.
+ *
+ * Tool registration is intentionally NOT done here — `buildMcpServer` calls
+ * `registerDiscoverTool(server, sessionCtx, vectorStore)` per session.
+ */
+export async function buildDiscoverComponents(config, store, syncEvents) {
     const embeddingsConfig = config.features?.embeddings;
     if (!embeddingsConfig) {
         process.stderr.write("[mcp-paprika] Semantic search: disabled\n");
-        return;
+        return null;
     }
     const embedder = new EmbeddingClient(embeddingsConfig);
     const vectorStore = new VectorStore(getCacheDir(), embedder, embeddingsConfig.model, EMBEDDING_SCHEMA_VERSION);
     await vectorStore.init();
-    registerDiscoverTool(server, ctx, vectorStore);
-    // Cold-start initial indexing: the initial sync.syncOnce() in index.ts fires
-    // sync:complete BEFORE this subscription exists. Re-index all recipes when
-    // the vector store is empty or significantly out of sync with the recipe
-    // store (e.g. stale test data, orphaned entries from a prior crash, or
-    // a model/dimension change that invalidated the old vectors).
-    if (ctx.store.size > 0 && vectorStore.size < ctx.store.size * 0.9) {
+    // Cold-start initial indexing: the initial sync.syncOnce() in the entry
+    // point fires sync:complete BEFORE this subscription exists. Re-index all
+    // recipes when the vector store is empty or significantly out of sync
+    // with the recipe store (stale test data, orphaned entries from a prior
+    // crash, or a model/dimension change that invalidated the old vectors).
+    if (store.size > 0 && vectorStore.size < store.size * 0.9) {
         vectorStore.clearHashes();
-        await vectorStore.indexRecipes(ctx.store.getAll(), (uids) => ctx.store.resolveCategories(uids));
+        await vectorStore.indexRecipes(store.getAll(), (uids) => store.resolveCategories(uids));
     }
-    sync.events.on("sync:complete", async (result) => {
+    syncEvents.on("sync:complete", async (result) => {
         try {
             const changed = [...result.added, ...result.updated];
             if (changed.length === 0 && result.removedUids.length === 0) {
                 return;
             }
             if (changed.length > 0) {
-                await vectorStore.indexRecipes(changed, (uids) => ctx.store.resolveCategories(uids));
+                await vectorStore.indexRecipes(changed, (uids) => store.resolveCategories(uids));
             }
             for (const uid of result.removedUids) {
                 await vectorStore.removeRecipe(uid);
@@ -39,4 +50,5 @@ export async function setupDiscoverFeature(server, ctx, sync, config) {
         }
     });
     process.stderr.write("[mcp-paprika] Semantic search: enabled\n");
+    return vectorStore;
 }

package/dist/index.js

@@ -1,100 +1,31 @@
 #!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { PaprikaClient } from "./paprika/client.js";
-import { SyncEngine } from "./paprika/sync.js";
-import { DiskCache } from "./cache/disk-cache.js";
-import { RecipeStore } from "./cache/recipe-store.js";
+import { startHttp } from "./transport/http.js";
+import { startStdio } from "./transport/stdio.js";
 import { loadConfig } from "./utils/config.js";
-import { getCacheDir } from "./utils/xdg.js";
-import { registerSearchTool } from "./tools/search.js";
-import { registerFilterTools } from "./tools/filter.js";
-import { registerCategoryTools } from "./tools/categories.js";
-import { registerReadTool } from "./tools/read.js";
-import { registerCreateTool } from "./tools/create.js";
-import { registerUpdateTool } from "./tools/update.js";
-import { registerDeleteTool } from "./tools/delete.js";
-import { registerListTool } from "./tools/list.js";
-import { registerRecipeResources } from "./resources/recipes.js";
-import { setupDiscoverFeature } from "./features/discover-feature.js";
 function log(msg) {
     process.stderr.write(`[mcp-paprika] ${msg}\n`);
 }
 async function main() {
-    // 1. Load and validate config
     log("Loading configuration...");
-    const configResult = loadConfig();
-    const config = configResult.match((cfg) => cfg, (err) => {
+    const config = loadConfig().match((cfg) => cfg, (err) => {
         throw err;
     });
-    // 2. Construct PaprikaClient and authenticate
-    log("Authenticating with Paprika...");
-    const client = new PaprikaClient(config.paprika.email, config.paprika.password);
-    await client.authenticate();
-    log("Authenticated successfully.");
-    // 3. Construct DiskCache and initialize
-    log("Initializing disk cache...");
-    const cache = new DiskCache(getCacheDir());
-    await cache.init();
-    // 4. Construct RecipeStore and hydrate from cache
-    const store = new RecipeStore();
-    const cachedRecipes = await cache.getAllRecipes();
-    for (const recipe of cachedRecipes) {
-        store.set(recipe);
-    }
-    log(`Hydrated store with ${cachedRecipes.length} cached recipes.`);
-    // 5. Construct McpServer
-    const server = new McpServer({
-        name: "mcp-paprika",
-        version: "0.0.0",
-    });
-    // 6. Assemble ServerContext
-    const ctx = {
-        client,
-        cache,
-        store,
-        server,
+    const handle = config.transport === "http" ? await startHttp(config) : await startStdio(config);
+    const onSignal = (signal) => {
+        log(`${signal} received, shutting down...`);
+        handle.shutdown().then(() => process.exit(0), (err) => {
+            process.stderr.write(`[mcp-paprika] Shutdown error: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        });
     };
-    // 7. Register all 9 tools
-    registerSearchTool(server, ctx);
-    registerFilterTools(server, ctx);
-    registerCategoryTools(server, ctx);
-    registerListTool(server, ctx);
-    registerReadTool(server, ctx);
-    registerCreateTool(server, ctx);
-    registerUpdateTool(server, ctx);
-    registerDeleteTool(server, ctx);
-    log("Registered 9 tools.");
-    // 8. Register recipe resources
-    registerRecipeResources(server, ctx);
-    log("Registered recipe resources.");
-    // 9. Construct SyncEngine, run initial sync, then start background loop
-    const sync = new SyncEngine(ctx, config.sync.interval);
-    log("Running initial sync...");
-    await sync.syncOnce();
-    log("Initial sync complete.");
-    if (config.sync.enabled) {
-        sync.start();
-        log(`Sync engine started (interval: ${config.sync.interval}ms).`);
-    }
-    else {
-        log("Background sync disabled.");
-    }
-    // Phase 3: Semantic search
-    await setupDiscoverFeature(server, ctx, sync, config);
-    // 10. Register SIGINT handler
     process.on("SIGINT", () => {
-        log("SIGINT received, shutting down...");
-        sync.stop();
-        process.exit(0);
+        onSignal("SIGINT");
+    });
+    process.on("SIGTERM", () => {
+        onSignal("SIGTERM");
     });
-    // 11. Connect stdio transport
-    log("Connecting stdio transport...");
-    await server.connect(new StdioServerTransport());
-    log("Server ready.");
 }
 main().catch((err) => {
-    /* oxlint-disable-next-line no-console */
-    console.error(err instanceof Error ? err.message : String(err));
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
     process.exit(1);
 });

package/dist/paprika/client.d.ts

@@ -7,7 +7,7 @@
  * Provides recipe and category read methods, plus write methods
  * added in P1-U07 (saveRecipe, deleteRecipe, notifySync).
  */
-import type { Category, Recipe, RecipeEntry, RecipeUid } from "./types.js";
+import type { Category, PantryItem, Recipe, RecipeEntry, RecipeUid } from "./types.js";
 export declare class PaprikaClient {
     private readonly email;
     private readonly password;
@@ -19,9 +19,12 @@ export declare class PaprikaClient {
     getRecipe(uid: string): Promise<Recipe>;
     getRecipes(uids: ReadonlyArray<string>): Promise<Array<Recipe>>;
     listCategories(): Promise<Array<Category>>;
+    listPantry(): Promise<Array<PantryItem>>;
     saveRecipe(recipe: Readonly<Recipe>): Promise<Recipe>;
+    savePantryItem(item: Readonly<PantryItem>): Promise<PantryItem>;
     notifySync(): Promise<void>;
     deleteRecipe(uid: RecipeUid): Promise<void>;
     private buildRecipeFormData;
+    private buildPantryFormData;
     private request;
 }