@bojanrajkovic/mcp-paprika 1.5.0-beta.2 → 1.5.0

package/dist/paprika/client.js

@@ -176,16 +176,58 @@ export class PaprikaClient {
         });
     }
     async authenticate() {
-        const response = await fetch(AUTH_URL, {
-            method: "POST",
-            body: new URLSearchParams({ email: this.email, password: this.password }),
-        });
-        if (!response.ok) {
-            throw new PaprikaAuthError(`Authentication failed (HTTP ${response.status.toString()})`);
+        // One authentication attempt. Classifies failures the same way request()
+        // does so the shared retry policy can tell transient blips (retry) from a
+        // real auth rejection (fail fast).
+        const attempt = async () => {
+            let response;
+            try {
+                response = await fetch(AUTH_URL, {
+                    method: "POST",
+                    body: new URLSearchParams({ email: this.email, password: this.password }),
+                });
+            }
+            catch (error) {
+                // undici throws a bare TypeError for network-level failures (DNS, TCP
+                // reset, TLS handshake). Mark it retryable so a transient blip at
+                // startup backs off and retries instead of crashlooping the process (#158).
+                if (error instanceof TypeError) {
+                    throw new NetworkRetryableError(error);
+                }
+                throw error;
+            }
+            if (!response.ok) {
+                // Transient upstream failures (5xx / 429) are worth retrying; a real
+                // auth rejection (401/403, bad credentials) is not — fail fast.
+                if (RETRYABLE_STATUSES.has(response.status)) {
+                    throw new TransientHTTPError(response.status);
+                }
+                throw new PaprikaAuthError(`Authentication failed (HTTP ${response.status.toString()})`);
+            }
+            const json = await response.json();
+            const data = AuthResponseSchema.parse(json);
+            this.token = data.result.token;
+        };
+        // Reuse the same bounded retry policy as request() (maxAttempts: 3, exp
+        // backoff) so a transient network/5xx failure at startup retries instead of
+        // throwing on the first blip. The circuit breaker is intentionally NOT
+        // applied — startup auth is one-shot, not a hot path. Non-retryable errors
+        // (PaprikaAuthError on bad creds, ZodError on a malformed body) are not
+        // matched by the policy and propagate immediately.
+        try {
+            await this.retryPolicy.execute(attempt);
+        }
+        catch (error) {
+            // Once the bounded retries are exhausted, surface a clean PaprikaAuthError
+            // (preserving the underlying cause) rather than the internal retry marker.
+            if (error instanceof NetworkRetryableError) {
+                throw new PaprikaAuthError("Authentication failed (network error)", { cause: error.cause });
+            }
+            if (error instanceof TransientHTTPError) {
+                throw new PaprikaAuthError(`Authentication failed (HTTP ${error.status.toString()})`, { cause: error });
+            }
+            throw error;
         }
-        const json = await response.json();
-        const data = AuthResponseSchema.parse(json);
-        this.token = data.result.token;
     }
     async listRecipes() {
         return this.request("GET", `${API_BASE}/recipes/`, z.array(RecipeEntrySchema));

package/dist/tools/filter.js

@@ -34,7 +34,11 @@ export function registerFilterTools(server, ctx) {
         }, (guard) => guard);
     });
     server.registerTool("filter_by_time", {
-        description: "Filter recipes by prep, cook, or total time. All constraints are optional. Results sorted by total time ascending.",
+        description: "Filter recipes by prep, cook, or total time. All constraints are optional; results are sorted by " +
+            "total time ascending. ADVISORY: a recipe whose relevant time can't be parsed (free-text like " +
+            '"5+ hours" or "overnight") is NOT hidden — it is included and flagged "Time unverified" so quick ' +
+            "recipes with odd time strings aren't silently dropped. For any flagged result, check the displayed " +
+            "time yourself rather than trusting the filter for that one.",
         inputSchema: {
             maxPrepTime: z.string().optional().describe('Maximum prep time (e.g., "30 minutes", "1 hr")'),
             maxCookTime: z.string().optional().describe('Maximum cook time (e.g., "45 min", "1 hour")'),
@@ -66,7 +70,7 @@ export function registerFilterTools(server, ctx) {
                 if (results.length === 0) {
                     return textResult("No recipes found matching the specified time constraints.");
                 }
-                return textResult(formatRecipeList(results, ctx));
+                return textResult(formatTimeFilterResults(results, ctx, constraints));
             }, (errorMsg) => textResult(errorMsg));
         }, (guard) => guard);
     });
@@ -97,3 +101,41 @@ function formatRecipeItem(recipe, categoryNames) {
     lines.push(...recipeMetadataLines(recipe));
     return lines.join("\n");
 }
+// Which active time constraints could NOT be confirmed for this recipe. A recipe
+// is "verified" against a constraint only when its corresponding field parses —
+// inclusion already guarantees it's within the bound, since the store excludes
+// parse-and-exceed recipes. A null or unparseable field (free-text like
+// "5+ hours" or "overnight") is kept (the store stays lenient — AC5.5 / issue
+// #162) but can't be confirmed, so filter_by_time flags it as advisory rather
+// than silently presenting it as a clean match.
+function unverifiedTimeFields(recipe, constraints) {
+    const unverified = [];
+    const check = (max, value, label) => {
+        if (max === undefined)
+            return;
+        const parses = value !== null &&
+            parseDuration(value).match(() => true, () => false);
+        if (!parses)
+            unverified.push(label);
+    };
+    check(constraints.maxPrepTime, recipe.prepTime, "prep time");
+    check(constraints.maxCookTime, recipe.cookTime, "cook time");
+    check(constraints.maxTotalTime, recipe.totalTime, "total time");
+    return unverified;
+}
+// filter_by_time-specific renderer: same item formatting as filter_by_ingredient,
+// plus a one-line "Time unverified" advisory appended to any recipe whose time
+// couldn't be confirmed against the active constraints.
+function formatTimeFilterResults(recipes, ctx, constraints) {
+    return recipes
+        .map((recipe) => {
+        const categoryNames = ctx.store.resolveCategories(recipe.categories);
+        const item = formatRecipeItem(recipe, categoryNames);
+        const unverified = unverifiedTimeFields(recipe, constraints);
+        if (unverified.length === 0)
+            return item;
+        return (`${item}\n> ⚠️ _Time unverified — couldn't parse this recipe's ${unverified.join(" / ")} against your ` +
+            `limit, so it's shown rather than hidden. Check the displayed time before relying on it._`);
+    })
+        .join("\n\n---\n\n");
+}

package/dist/tools/menu-item-write.d.ts

@@ -15,7 +15,7 @@ export declare const addMenuItemsInputSchema: z.ZodObject<{
     }, {
         name: string;
     }>]>;
-    items: z.ZodArray<z.ZodObject<{
+    items: z.ZodArray<z.ZodUnion<[z.ZodObject<{
         recipe_uid: z.ZodBranded<z.ZodString, "RecipeUid">;
         day: z.ZodNumber;
         type: z.ZodUnion<[z.ZodObject<{
@@ -57,9 +57,51 @@ export declare const addMenuItemsInputSchema: z.ZodObject<{
         };
         recipe_uid: string;
         day: number;
-    }>, "many">;
+    }>, z.ZodObject<{
+        name: z.ZodString;
+        day: z.ZodNumber;
+        type: z.ZodUnion<[z.ZodObject<{
+            name: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+        }, {
+            name: string;
+        }>, z.ZodObject<{
+            uid: z.ZodBranded<z.ZodString, "MealTypeUid">;
+        }, "strict", z.ZodTypeAny, {
+            uid: string & z.BRAND<"MealTypeUid">;
+        }, {
+            uid: string;
+        }>, z.ZodObject<{
+            builtin: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            builtin: number;
+        }, {
+            builtin: number;
+        }>]>;
+    }, "strict", z.ZodTypeAny, {
+        type: {
+            name: string;
+        } | {
+            uid: string & z.BRAND<"MealTypeUid">;
+        } | {
+            builtin: number;
+        };
+        name: string;
+        day: number;
+    }, {
+        type: {
+            name: string;
+        } | {
+            uid: string;
+        } | {
+            builtin: number;
+        };
+        name: string;
+        day: number;
+    }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
-    items: {
+    items: ({
         type: {
             name: string;
         } | {
@@ -69,14 +111,24 @@ export declare const addMenuItemsInputSchema: z.ZodObject<{
         };
         recipe_uid: string & z.BRAND<"RecipeUid">;
         day: number;
-    }[];
+    } | {
+        type: {
+            name: string;
+        } | {
+            uid: string & z.BRAND<"MealTypeUid">;
+        } | {
+            builtin: number;
+        };
+        name: string;
+        day: number;
+    })[];
     menu: {
         uid: string & z.BRAND<"MenuUid">;
     } | {
         name: string;
     };
 }, {
-    items: {
+    items: ({
         type: {
             name: string;
         } | {
@@ -86,7 +138,17 @@ export declare const addMenuItemsInputSchema: z.ZodObject<{
         };
         recipe_uid: string;
         day: number;
-    }[];
+    } | {
+        type: {
+            name: string;
+        } | {
+            uid: string;
+        } | {
+            builtin: number;
+        };
+        name: string;
+        day: number;
+    })[];
     menu: {
         uid: string;
     } | {

package/dist/tools/menu-item-write.js

@@ -5,20 +5,33 @@ import { MenuItemUidSchema, MenuUidSchema, RecipeUidSchema } from "../paprika/ty
 import { resolveLookup, textResult, uidOrTextLookupSchema } from "./helpers.js";
 import { mealTypeSpecSchema, resolveMealTypeSpec } from "./meal-helpers.js";
 import { commitMenu, commitMenuItem, commitMenuItemsBatch, menuStartGuard, menuToMarkdown } from "./menu-helpers.js";
-// One menuitem to add: a recipe-linked entry placed on a specific day with a
-// meal type. Display name auto-resolves from the recipe (like add_meals), so no
-// `name` field is accepted. `.strict()` rejects extra keys at the Zod boundary.
-const addMenuItemSchema = z
+// One menuitem to add. Structurally EITHER recipe-linked (recipe_uid; display
+// name auto-resolves from the recipe) OR freeform (name; no recipe), mirroring
+// add_meals — Paprika.app dispatches a menuitem's display off recipe_uid, so a
+// stored custom name on a recipe-linked item would never render. The z.union of
+// two `.strict()` objects rejects extra keys (including supplying BOTH recipe_uid
+// and name) at the Zod boundary, surfacing the constraint structurally.
+const menuItemDay = z
+    .number()
+    .int()
+    .positive()
+    .describe("1-indexed day within the menu. Days beyond the menu's current span auto-extend the menu.");
+const menuItemType = mealTypeSpecSchema.describe('Meal type. Pick exactly one shape: {"name": "Dinner"} | {"uid": "<MealType UID>"} | {"builtin": 2}.');
+const recipeMenuItemSchema = z
     .object({
     recipe_uid: RecipeUidSchema.describe("Recipe UID to place on the menu. Display name auto-resolves from the recipe."),
-    day: z
-        .number()
-        .int()
-        .positive()
-        .describe("1-indexed day within the menu. Days beyond the menu's current span auto-extend the menu."),
-    type: mealTypeSpecSchema.describe('Meal type. Pick exactly one shape: {"name": "Dinner"} | {"uid": "<MealType UID>"} | {"builtin": 2}.'),
+    day: menuItemDay,
+    type: menuItemType,
 })
     .strict();
+const freeformMenuItemSchema = z
+    .object({
+    name: z.string().min(1).describe("Display name for a freeform (non-recipe) menuitem."),
+    day: menuItemDay,
+    type: menuItemType,
+})
+    .strict();
+const addMenuItemSchema = z.union([recipeMenuItemSchema, freeformMenuItemSchema]);
 export const addMenuItemsInputSchema = z.object({
     menu: uidOrTextLookupSchema({
         uidSchema: MenuUidSchema,
@@ -29,18 +42,19 @@ export const addMenuItemsInputSchema = z.object({
     items: z
         .array(addMenuItemSchema)
         .min(1, "At least one menu item is required.")
-        .describe("Array of recipe-linked menuitems to add (1 or more)."),
+        .describe("Array of menuitems to add (1 or more); each is recipe-linked OR freeform."),
 });
 export function registerAddMenuItemsTool(server, ctx) {
     const log = ctx.log.child({ component: "add_menu_items" });
     server.registerTool("add_menu_items", {
-        description: "Add one or more recipe-linked menuitems to a menu (saved meal plan). Look the menu up by UID or " +
-            "name (tiered fuzzy match). Each item carries a recipe_uid (display name auto-resolves from the " +
-            "recipe), a 1-indexed day, and a meal type (name, UID, or built-in index 0=Breakfast, 1=Lunch, " +
-            "2=Dinner, 3=Snacks). If any day falls beyond the menu's current span the menu is automatically " +
-            "extended to fit before the items are added. All items validate up-front; if ANY item is invalid " +
-            "the entire batch is rejected with a per-index error enumeration so callers can fix every problem " +
-            "in one pass.",
+        description: "Add one or more menuitems to a menu (saved meal plan). Look the menu up by UID or name (tiered " +
+            "fuzzy match). Each item is EITHER recipe-linked (supply recipe_uid; display name auto-resolves " +
+            "from the recipe) OR freeform (supply name; no recipe) — the two are mutually exclusive, matching " +
+            "add_meals. Each item also carries a 1-indexed day and a meal type (name, UID, or built-in index " +
+            "0=Breakfast, 1=Lunch, 2=Dinner, 3=Snacks). If any day falls beyond the menu's current span the " +
+            "menu is automatically extended to fit before the items are added. All items validate up-front; " +
+            "if ANY item is invalid the entire batch is rejected with a per-index error enumeration so callers " +
+            "can fix every problem in one pass.",
         inputSchema: addMenuItemsInputSchema.shape,
     }, async (args) => {
         log.info({ tool: "add_menu_items", ...args.menu, count: args.items.length }, "tool invoked");
@@ -67,13 +81,25 @@ export function registerAddMenuItemsTool(server, ctx) {
             const resolved = [];
             for (let i = 0; i < args.items.length; i++) {
                 const item = args.items[i];
-                // Recipe must be known to the local store so we can denormalize the
-                // display name (matching add_meals' recipe-link contract).
-                const recipe = ctx.store.get(item.recipe_uid);
-                if (recipe === undefined) {
-                    errors.push(`Item ${i.toString()}: recipe_uid "${item.recipe_uid}" is not known to the local recipe store; ` +
-                        `wait for the next sync and retry.`);
-                    continue;
+                // Recipe-linked XOR freeform — the structural union guarantees exactly
+                // one shape. Recipe items denormalize the display name from the local
+                // store (matching add_meals' recipe-link contract); freeform items keep
+                // the supplied name and store recipeUid: null.
+                let recipeUid;
+                let resolvedName;
+                if ("recipe_uid" in item) {
+                    const recipe = ctx.store.get(item.recipe_uid);
+                    if (recipe === undefined) {
+                        errors.push(`Item ${i.toString()}: recipe_uid "${item.recipe_uid}" is not known to the local recipe store; ` +
+                            `wait for the next sync and retry, or supply a freeform item (omit recipe_uid, supply name).`);
+                        continue;
+                    }
+                    recipeUid = item.recipe_uid;
+                    resolvedName = recipe.name;
+                }
+                else {
+                    recipeUid = null;
+                    resolvedName = item.name;
                 }
                 // Meal type resolution via the shared helper (same DU as add_meals).
                 const typeResult = resolveMealTypeSpec(ctx, item.type);
@@ -95,8 +121,8 @@ export function registerAddMenuItemsTool(server, ctx) {
                 resolved.push({
                     day: item.day,
                     typeUid: typeResult.resolved.uid,
-                    resolvedName: recipe.name,
-                    recipeUid: item.recipe_uid,
+                    resolvedName,
+                    recipeUid,
                 });
             }
             if (errors.length > 0) {

package/dist/utils/duration.js

@@ -34,7 +34,13 @@ function colonParser(input) {
     return ok(Duration.fromObject({ hours, minutes }));
 }
 function humanAndIsoParser(input) {
-    const ms = parseDurationLib(input);
+    // parse-duration reads a number with a detached "+" (e.g. "5+ hours") as a bare
+    // millisecond count — "5" → 5ms — silently producing a wildly-wrong tiny value
+    // instead of "5 hours". Recipe time fields are full of these ("3+ hours",
+    // "10 min (plus 4+ hours rest)"). Strip a "+" that immediately follows a number
+    // so the duration reads correctly (#162).
+    const normalized = input.replace(/(\d)\s*\+/g, "$1");
+    const ms = parseDurationLib(normalized);
     if (ms === null || ms === undefined) {
         return null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bojanrajkovic/mcp-paprika",
-  "version": "1.5.0-beta.2",
+  "version": "1.5.0",
   "description": "MCP server for Paprika recipe manager",
   "license": "MIT",
   "repository": {