@bojanrajkovic/mcp-paprika 1.0.0

package/dist/utils/config.js

@@ -0,0 +1,197 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import dotenv from "dotenv";
+import { ok, err } from "neverthrow";
+import { parseDuration } from "./duration.js";
+import { getConfigDir } from "./xdg.js";
+const ENV_VAR_HINTS = {
+    "paprika.email": "PAPRIKA_EMAIL",
+    "paprika.password": "PAPRIKA_PASSWORD",
+    "sync.interval": "PAPRIKA_SYNC_INTERVAL",
+    "sync.enabled": "PAPRIKA_SYNC_ENABLED",
+    "features.replicateApiToken": "REPLICATE_API_TOKEN",
+    "features.embeddings.apiKey": "OPENAI_API_KEY",
+    "features.embeddings.baseUrl": "OPENAI_BASE_URL",
+    "features.embeddings.model": "EMBEDDING_MODEL",
+};
+export class ConfigError extends Error {
+    reason;
+    kind;
+    constructor(reason, kind) {
+        super(reason);
+        this.name = "ConfigError";
+        this.reason = reason;
+        this.kind = kind;
+    }
+    static invalidJson(path, cause) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        return new ConfigError(`Invalid JSON in ${path}: ${detail}`, "invalid_json");
+    }
+    static fileReadError(path, cause) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        return new ConfigError(`Cannot read ${path}: ${detail}`, "file_read_error");
+    }
+    static validation(issues) {
+        const lines = issues.map((issue) => {
+            const path = issue.path.join(".");
+            const hint = ENV_VAR_HINTS[path];
+            const suffix = hint ? ` (set via ${hint})` : "";
+            return `  - ${path}: ${issue.message}${suffix}`;
+        });
+        const reason = `Configuration validation failed:\n${lines.join("\n")}`;
+        return new ConfigError(reason, "validation");
+    }
+}
+const durationField = z.union([z.string(), z.number()]).transform((val, ctx) => {
+    return parseDuration(val).match((duration) => duration.as("milliseconds"), (parseErr) => {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: parseErr.reason,
+        });
+        return z.NEVER;
+    });
+});
+const BOOLEAN_STRINGS = {
+    true: true,
+    false: false,
+    "1": true,
+    "0": false,
+};
+const booleanField = z.union([z.boolean(), z.string()]).transform((val, ctx) => {
+    if (typeof val === "boolean") {
+        return val;
+    }
+    const mapped = BOOLEAN_STRINGS[val];
+    if (mapped === undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `expected "true", "false", "1", or "0", got ${JSON.stringify(val)}`,
+        });
+        return z.NEVER;
+    }
+    return mapped;
+});
+const embeddingConfigSchema = z.object({
+    apiKey: z.string().min(1),
+    baseUrl: z.string().min(1),
+    model: z.string().min(1),
+});
+export const paprikaConfigSchema = z.object({
+    paprika: z.preprocess((val) => val ?? {}, z.object({
+        email: z.string().min(1),
+        password: z.string().min(1),
+    })),
+    sync: z
+        .object({
+        enabled: booleanField.default(true),
+        interval: durationField.default("15m"),
+    })
+        .default({}),
+    features: z
+        .object({
+        replicateApiToken: z.string().min(1).optional(),
+        embeddings: embeddingConfigSchema.optional(),
+    })
+        .optional(),
+});
+// Type guard for NodeJS.ErrnoException
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+// Reads config.json from configDir. ENOENT returns ok({}). Invalid JSON and permission errors return err.
+function readConfigFile(configDir) {
+    const filePath = join(configDir, "config.json");
+    let content;
+    try {
+        content = readFileSync(filePath, "utf-8");
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return ok({});
+        }
+        return err(ConfigError.fileReadError(filePath, error));
+    }
+    try {
+        const parsed = JSON.parse(content);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            return err(ConfigError.invalidJson(filePath, new Error("expected a JSON object")));
+        }
+        return ok(parsed);
+    }
+    catch (error) {
+        return err(ConfigError.invalidJson(filePath, error));
+    }
+}
+// Loads .env file from configDir into process.env. Missing .env is silently ignored.
+function loadDotEnv(configDir) {
+    dotenv.config({ path: join(configDir, ".env") });
+}
+// Maps known env vars to the nested config object structure.
+function buildEnvOverrides(env) {
+    const overrides = {};
+    const paprika = {};
+    const sync = {};
+    const features = {};
+    const embeddings = {};
+    if (env["PAPRIKA_EMAIL"] !== undefined)
+        paprika["email"] = env["PAPRIKA_EMAIL"];
+    if (env["PAPRIKA_PASSWORD"] !== undefined)
+        paprika["password"] = env["PAPRIKA_PASSWORD"];
+    if (env["PAPRIKA_SYNC_INTERVAL"] !== undefined)
+        sync["interval"] = env["PAPRIKA_SYNC_INTERVAL"];
+    if (env["PAPRIKA_SYNC_ENABLED"] !== undefined)
+        sync["enabled"] = env["PAPRIKA_SYNC_ENABLED"];
+    if (env["REPLICATE_API_TOKEN"] !== undefined)
+        features["replicateApiToken"] = env["REPLICATE_API_TOKEN"];
+    if (env["OPENAI_API_KEY"] !== undefined)
+        embeddings["apiKey"] = env["OPENAI_API_KEY"];
+    if (env["OPENAI_BASE_URL"] !== undefined)
+        embeddings["baseUrl"] = env["OPENAI_BASE_URL"];
+    if (env["EMBEDDING_MODEL"] !== undefined)
+        embeddings["model"] = env["EMBEDDING_MODEL"];
+    if (Object.keys(embeddings).length > 0)
+        features["embeddings"] = embeddings;
+    if (Object.keys(features).length > 0)
+        overrides["features"] = features;
+    if (Object.keys(paprika).length > 0)
+        overrides["paprika"] = paprika;
+    if (Object.keys(sync).length > 0)
+        overrides["sync"] = sync;
+    return overrides;
+}
+// Recursively merges base config with overrides. Override values win for non-object fields.
+/** @internal Pure helper for config merging. Exported for property-based testing only. */
+export function deepMerge(base, overrides) {
+    const result = { ...base };
+    for (const key of Object.keys(overrides)) {
+        const baseVal = base[key];
+        const overVal = overrides[key];
+        if (typeof baseVal === "object" &&
+            baseVal !== null &&
+            !Array.isArray(baseVal) &&
+            typeof overVal === "object" &&
+            overVal !== null &&
+            !Array.isArray(overVal)) {
+            result[key] = deepMerge(baseVal, overVal);
+        }
+        else {
+            result[key] = overVal;
+        }
+    }
+    return result;
+}
+// Orchestrates the full config loading pipeline. Accepts optional configDir for testability.
+export function loadConfig(configDir) {
+    const dir = configDir ?? getConfigDir();
+    loadDotEnv(dir);
+    return readConfigFile(dir).andThen((fileConfig) => {
+        const envOverrides = buildEnvOverrides(process.env);
+        const merged = deepMerge(fileConfig, envOverrides);
+        const parseResult = paprikaConfigSchema.safeParse(merged);
+        if (!parseResult.success) {
+            return err(ConfigError.validation(parseResult.error.issues));
+        }
+        return ok(parseResult.data);
+    });
+}

package/dist/utils/duration.d.ts

@@ -0,0 +1,10 @@
+import { Duration } from "luxon";
+import { type Result } from "neverthrow";
+export declare class DurationParseError extends Error {
+    readonly input: string | number;
+    readonly reason: string;
+    private constructor();
+    static fromInput(input: string | number, reason: string): DurationParseError;
+}
+export declare function parseDuration(input: string | number): Result<Duration, DurationParseError>;
+export declare function formatDuration(duration: Duration): string;

package/dist/utils/duration.js

@@ -0,0 +1,86 @@
+import { Duration } from "luxon";
+import { ok, err } from "neverthrow";
+import parseDurationLib from "parse-duration";
+export class DurationParseError extends Error {
+    input;
+    reason;
+    constructor(input, reason) {
+        super(`Invalid duration ${JSON.stringify(input)}: ${reason}`);
+        this.name = "DurationParseError";
+        this.input = input;
+        this.reason = reason;
+    }
+    static fromInput(input, reason) {
+        return new DurationParseError(input, reason);
+    }
+}
+function numericParser(input) {
+    if (!/^\d+(\.\d+)?$/.test(input)) {
+        return null;
+    }
+    const minutes = Number(input);
+    return ok(Duration.fromObject({ minutes }));
+}
+function colonParser(input) {
+    const match = /^(\d+):(\d{1,2})$/.exec(input);
+    if (!match) {
+        return null;
+    }
+    const hours = Number(match[1]);
+    const minutes = Number(match[2]);
+    if (minutes >= 60) {
+        return err(DurationParseError.fromInput(input, "minutes must be less than 60"));
+    }
+    return ok(Duration.fromObject({ hours, minutes }));
+}
+function humanAndIsoParser(input) {
+    const ms = parseDurationLib(input);
+    if (ms === null || ms === undefined) {
+        return null;
+    }
+    if (ms < 0) {
+        return err(DurationParseError.fromInput(input, "negative duration"));
+    }
+    return ok(Duration.fromMillis(ms));
+}
+export function parseDuration(input) {
+    if (typeof input === "number") {
+        if (!Number.isFinite(input)) {
+            return err(DurationParseError.fromInput(input, "input must be a finite number"));
+        }
+        if (input < 0) {
+            return err(DurationParseError.fromInput(input, "negative duration"));
+        }
+        return ok(Duration.fromObject({ minutes: input }));
+    }
+    const trimmed = input.trim();
+    if (trimmed === "") {
+        return err(DurationParseError.fromInput(input, "empty input"));
+    }
+    const parsers = [numericParser, colonParser, humanAndIsoParser];
+    for (const parser of parsers) {
+        const result = parser(trimmed);
+        if (result !== null) {
+            return result;
+        }
+    }
+    return err(DurationParseError.fromInput(input, "unrecognized duration format"));
+}
+export function formatDuration(duration) {
+    if (!duration.isValid) {
+        return "";
+    }
+    const totalMinutes = Math.round(duration.as("minutes"));
+    if (totalMinutes <= 0) {
+        return "";
+    }
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours > 0 && minutes > 0) {
+        return `${String(hours)} hr ${String(minutes)} min`;
+    }
+    if (hours > 0) {
+        return `${String(hours)} hr`;
+    }
+    return `${String(minutes)} min`;
+}

package/dist/utils/xdg.d.ts

@@ -0,0 +1,5 @@
+export declare function getConfigDir(): string;
+export declare function getCacheDir(): string;
+export declare function getDataDir(): string;
+export declare function getLogDir(): string;
+export declare function getTempDir(): string;

package/dist/utils/xdg.js

@@ -0,0 +1,17 @@
+import envPaths from "env-paths";
+const paths = envPaths("mcp-paprika", { suffix: "" });
+export function getConfigDir() {
+    return paths.config;
+}
+export function getCacheDir() {
+    return paths.cache;
+}
+export function getDataDir() {
+    return paths.data;
+}
+export function getLogDir() {
+    return paths.log;
+}
+export function getTempDir() {
+    return paths.temp;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@bojanrajkovic/mcp-paprika",
+  "version": "1.0.0",
+  "description": "MCP server for Paprika recipe manager",
+  "license": "MIT",
+  "bin": {
+    "mcp-paprika": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "lint": "oxlint --deny-warnings src/",
+    "lint:fix": "oxlint --fix src/",
+    "prepare": "lefthook install",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "cockatiel": "^3.2.1",
+    "dotenv": "^17.3.1",
+    "env-paths": "^4.0.0",
+    "luxon": "^3.7.2",
+    "mitt": "^3.0.1",
+    "neverthrow": "^8.2.0",
+    "parse-duration": "^2.1.5",
+    "vectra": "^0.12.3",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.5.0",
+    "@commitlint/config-conventional": "^20.5.0",
+    "@tsconfig/node24": "^24.0.4",
+    "@tsconfig/strictest": "^2.0.8",
+    "@types/luxon": "^3.7.1",
+    "@types/node": "^24.12.0",
+    "@vitest/coverage-v8": "^4.1.0",
+    "fast-check": "^4.6.0",
+    "lefthook": "^2.1.4",
+    "msw": "^2.12.14",
+    "oxfmt": "^0.41.0",
+    "oxlint": "^1.56.0",
+    "tsx": "^4.21",
+    "type-fest": "^5.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
+  },
+  "engines": {
+    "node": ">=24.14.0"
+  },
+  "packageManager": "pnpm@10.32.1"
+}