vault-cortex 0.13.1 → 0.13.2

package/dist/init.js

@@ -86,28 +86,52 @@ const parseHttpUrl = (value) => {
         return null;
     }
 };
+/** Validates a PUBLIC_URL value: must be http(s), no credentials, no /mcp suffix. */
+export const validatePublicUrl = (input) => {
+    const trimmed = input.trim();
+    const url = parseHttpUrl(trimmed);
+    if (!url) {
+        return {
+            kind: "error",
+            message: "PUBLIC_URL must be a full http:// or https:// URL (e.g. https://vault.example.com).",
+        };
+    }
+    if (url.username || url.password) {
+        return {
+            kind: "error",
+            message: "PUBLIC_URL must not contain credentials (user:password@).",
+        };
+    }
+    // Raw-string check: url.search/url.hash return "" for bare delimiters
+    // (WHATWG spec treats empty-string and null query/fragment identically),
+    // so a parsed-property check misses "https://host/?" and "https://host/#".
+    if (trimmed.includes("?") || trimmed.includes("#")) {
+        return {
+            kind: "error",
+            message: "PUBLIC_URL must be a bare origin or path — no query string (?...) or fragment (#...).",
+        };
+    }
+    if (TRAILING_MCP_PATH.test(url.pathname)) {
+        return {
+            kind: "error",
+            message: "Leave /mcp off PUBLIC_URL — it's the base URL and the server adds /mcp itself (e.g. https://vault.example.com).",
+        };
+    }
+    // Trim trailing slashes so the connect URL is `${base}/mcp`, never
+    // `${base}//mcp` — URL.href/.origin don't round-trip reverse-proxy subpaths.
+    return { kind: "ok", url: trimmed.replace(/\/+$/, "") };
+};
 /** Re-prompts until the answer is a valid base http(s) URL (no /mcp path). */
 const askPublicUrl = async (prompts) => {
     const answer = await prompts.text("Public base URL clients will use to reach this server (no /mcp — it's added for you):", {
         placeholder: "https://vault.example.com or http://203.0.113.10:8000",
     });
-    const trimmed = answer.trim();
-    const url = parseHttpUrl(trimmed);
-    if (url === null) {
-        prompts.error("PUBLIC_URL must be a full http:// or https:// URL (e.g. https://vault.example.com).");
-        return askPublicUrl(prompts);
-    }
-    // Reject a re-included endpoint path instead of stripping it silently —
-    // PUBLIC_URL is the base origin and the server adds /mcp itself.
-    if (TRAILING_MCP_PATH.test(url.pathname)) {
-        prompts.error("Leave /mcp off PUBLIC_URL — it's the base URL and the server adds /mcp itself (e.g. https://vault.example.com).");
+    const result = validatePublicUrl(answer);
+    if (result.kind === "error") {
+        prompts.error(result.message);
         return askPublicUrl(prompts);
     }
-    // Store the input as typed, trimming only a trailing slash so the connect
-    // URL is `${base}/mcp`, never `${base}//mcp`. URL's own normalization is
-    // unusable here: `.href` adds a trailing slash and `.origin` drops the path,
-    // so neither round-trips a reverse-proxy subpath like https://host/api.
-    return trimmed.replace(/\/+$/, "");
+    return result.url;
 };
 /** Re-prompts until non-empty. */
 const askVaultName = async (prompts) => {

package/dist/optional-settings.js

@@ -1,4 +1,6 @@
 import { DEFAULT_PORT } from "./scaffold.js";
+/** Matches Moment.js [...] literal escape groups, splitting format spans from literal content. */
+const MOMENT_BRACKET_ESCAPE = /\[([^\]]*)\]/g;
 // The curated prompt set — settings users most often want without reading
 // .env comments. Everything else stays documented-only in the generated
 // optional block, deliberately: every extra prompt costs init flow length.
@@ -23,6 +25,13 @@ const OPTIONAL_SETTINGS = [
         label: "Daily notes folder",
         question: "Vault folder for daily notes:",
         placeholder: "blank = use your vault's daily notes settings",
+        validate: (value) => {
+            if (value.includes(".."))
+                return "Path traversal (..) is not allowed in folder names.";
+            if (value.startsWith("/"))
+                return "Absolute paths are not allowed — use a vault-relative folder name.";
+            return undefined;
+        },
     },
     {
         kind: "optionalText",
@@ -30,6 +39,21 @@ const OPTIONAL_SETTINGS = [
         label: "Daily notes format",
         question: "Filename date format for daily notes (e.g. YYYY-MM-DD):",
         placeholder: "blank = use your vault's daily notes settings",
+        validate: (value) => {
+            if (value.includes(".."))
+                return "Date format must not contain path traversal (..).";
+            if (value.startsWith("/"))
+                return "Date format must not start with a path separator.";
+            if (value.endsWith("/"))
+                return "Date format must not end with a path separator.";
+            // Moment format tokens are all letters — digits outside of [...]
+            // bracket escapes are almost always a mistake.
+            const formatSegments = value.split(MOMENT_BRACKET_ESCAPE);
+            const hasDigitsInFormat = formatSegments.some((segment, index) => index % 2 === 0 && /\d/.test(segment));
+            if (hasDigitsInFormat)
+                return "Date format should use Moment tokens (YYYY, MM, DD), not digits — wrap literal text in [...] brackets.";
+            return undefined;
+        },
     },
     {
         kind: "toggle",
@@ -193,8 +217,17 @@ const askFolder = async (params, prompts) => {
         defaultValue: currentValue ?? defaultValue,
         placeholder: defaultValue,
     })).trim();
-    if (answer !== "")
+    if (answer !== "") {
+        if (answer.includes("..")) {
+            prompts.error("Path traversal (..) is not allowed in folder names.");
+            return askFolder(params, prompts);
+        }
+        if (answer.startsWith("/")) {
+            prompts.error("Absolute paths are not allowed — use a vault-relative folder name.");
+            return askFolder(params, prompts);
+        }
         return answer;
+    }
     prompts.error("The folder name can't be empty.");
     return askFolder(params, prompts);
 };
@@ -251,12 +284,21 @@ const askSettingValue = async (params, prompts) => {
                 currentValue,
                 defaultValue: setting.defaultValue,
             }, prompts);
-        case "optionalText":
-            return askOptionalText({
+        case "optionalText": {
+            const value = await askOptionalText({
                 question: setting.question,
                 placeholder: setting.placeholder,
                 currentValue,
             }, prompts);
+            if (value && setting.validate) {
+                const error = setting.validate(value);
+                if (error) {
+                    prompts.error(error);
+                    return askSettingValue(params, prompts);
+                }
+            }
+            return value;
+        }
         case "choice":
             return prompts.select(setting.question, setting.choices, currentValue ?? setting.defaultValue);
     }

package/dist/vault.js

@@ -21,6 +21,11 @@ export const validateVaultPath = (input) => {
     const trimmed = input.trim();
     if (trimmed === "")
         return { kind: "error", message: "Vault path is required." };
+    if (/[*?[]/.test(trimmed))
+        return {
+            kind: "error",
+            message: "Vault path must not contain glob characters (*, ?, [).",
+        };
     const absolutePath = resolve(expandTilde(trimmed));
     if (!existsSync(absolutePath)) {
         return { kind: "error", message: `Path does not exist: ${absolutePath}` };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vault-cortex",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "description": "Set up a Vault Cortex MCP server for your Obsidian vault in one command: npx vault-cortex@latest init",
   "license": "MIT",
   "type": "module",