vault-cortex 0.8.0 → 0.9.0

package/README.md

@@ -15,12 +15,14 @@ and data files — see the
 The server runs as a Docker container; this CLI scaffolds the config and
 manages the container so you don't have to.
 
-![npx vault-cortex init — the interactive setup wizard picks a mode, finds your vault, generates the config, and starts the server](https://raw.githubusercontent.com/aliasunder/vault-cortex/main/assets/demo-cli-init.gif)
+![npx vault-cortex init — the interactive setup wizard picks a mode, finds your vault, offers the optional settings, generates the config, and starts the server](https://raw.githubusercontent.com/aliasunder/vault-cortex/main/assets/demo-cli-init.gif)
 
 ## Commands
 
 - [`init`](#init) — interactive setup: scaffold the config, generate the auth
   token, start the server
+- [`configure`](#configure) — change optional settings interactively and
+  restart to apply them
 - [`upgrade`](#upgrade) — pull the latest image and re-create the container;
   your data stays
 - [`restart`](#restart) — re-create the container so your `.env` edits take
@@ -44,9 +46,14 @@ What it does:
    - **Local** — Docker on this machine, your vault folder bind-mounted
    - **Remote** — a VPS with [Obsidian Sync](https://obsidian.md/sync),
      reachable from any device
-2. Generates a `.env` file with a securely generated `MCP_AUTH_TOKEN`
-3. Optionally starts the container and waits for the health check
-4. Prints your connection details — the MCP URL, your auth token, and how to
+2. Offers the most common optional settings — memory layer and folder,
+   file tools, semantic search, port, timezone (plus sync direction for
+   remote) — press enter to keep the defaults, or pick the ones you want to
+   change. Skipped when the target directory already has a `.env` (use
+   [`configure`](#configure) instead)
+3. Generates a `.env` file with a securely generated `MCP_AUTH_TOKEN`
+4. Optionally starts the container and waits for the health check
+5. Prints your connection details — the MCP URL, your auth token, and how to
    connect your client
 
 Existing files are never overwritten without asking. During a remote setup,
@@ -67,6 +74,22 @@ Non-interactive example:
 npx vault-cortex@latest init --yes --vault-path /path/to/YourVault
 ```
 
+## configure
+
+Change optional settings on an existing setup:
+
+```bash
+npx vault-cortex@latest configure
+```
+
+Shows the same settings chooser as [`init`](#init) — memory layer and
+folder, file tools, semantic search, port, timezone (plus sync direction
+for remote) — pre-filled with your current values, saves your picks to
+`.env`, and offers to restart the container so they take effect. Settings not in the chooser
+live in `.env` too: edit the value there, then run [`restart`](#restart).
+
+Use `--dir <path>` if your config isn't in `./vault-cortex`.
+
 ## upgrade
 
 Pull the latest image, re-create the container, and verify health:

package/dist/configure.js

@@ -0,0 +1,64 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { recreateContainer, requireInitializedDir, resolveDeployment, } from "./lifecycle.js";
+import { applyOptionalSettings, askOptionalSettings, derivePublicUrlOverride, readOptionalValue, } from "./optional-settings.js";
+/**
+ * Interactively changes optional settings in an existing deployment's .env,
+ * then offers to re-create the container so the new values take effect (the
+ * env-file is only read at container creation). The edit succeeds on its own:
+ * a stopped daemon or a declined restart still exits 0 with the settings
+ * saved and a restart hint printed.
+ */
+export const runConfigure = async (flags, deps) => {
+    const { prompts, docker, fetchFn } = deps;
+    prompts.intro("vault-cortex configure");
+    // Editing settings only needs an init'd .env — the full start validation
+    // (VAULT_PATH, PUBLIC_URL) runs later, only when a restart is requested.
+    const initialized = requireInitializedDir(flags.dir, prompts);
+    if (!initialized)
+        return 1;
+    const { targetDir, envFilePath, mode } = initialized;
+    const envContent = readFileSync(envFilePath, "utf8");
+    const pickedOverrides = await askOptionalSettings({ mode, envContent }, prompts);
+    if (Object.keys(pickedOverrides).length === 0) {
+        prompts.log("No settings selected — nothing changed.");
+        prompts.outro("Done.");
+        return 0;
+    }
+    const overrides = derivePublicUrlOverride(envContent, pickedOverrides);
+    const changedNames = Object.keys(overrides);
+    writeFileSync(envFilePath, applyOptionalSettings(envContent, overrides));
+    prompts.log(`Updated ${changedNames.join(", ")} in ${targetDir}/.env.`);
+    // A custom PUBLIC_URL is never rewritten (see derivePublicUrlOverride), but
+    // a port change can still strand it — surface the consequence non-blocking.
+    const currentPublicUrl = readOptionalValue(envContent, "PUBLIC_URL");
+    if (pickedOverrides.PORT && !overrides.PUBLIC_URL && currentPublicUrl) {
+        prompts.warn(`PORT changed — make sure PUBLIC_URL (${currentPublicUrl}) still reaches the server.`);
+    }
+    const restartHint = `Apply the new settings with: npx vault-cortex restart --dir "${targetDir}"`;
+    if (!docker.isDaemonRunning()) {
+        prompts.warn(`Container runtime not running — settings saved.\n${restartHint}`);
+        prompts.outro("Done.");
+        return 0;
+    }
+    const restartNow = await prompts.confirm("Restart the container now to apply the new settings?", true);
+    if (!restartNow) {
+        prompts.log(restartHint);
+        prompts.outro("Done.");
+        return 0;
+    }
+    // Resolve from disk after the write so the restart honors the new values
+    // (a changed PORT must drive the port mapping and health URL).
+    const deployment = resolveDeployment(flags.dir, prompts);
+    if (!deployment) {
+        // The edit already succeeded — don't let the failed restart read as a
+        // failed configure.
+        prompts.warn(`The restart did not run — your settings are saved. Fix the issue above, then apply them with: npx vault-cortex restart --dir "${targetDir}"`);
+        return 1;
+    }
+    const exitCode = await recreateContainer({ deployment, healthTimeoutMs: deps.healthTimeoutMs }, { prompts, docker, fetchFn });
+    if (exitCode !== 0)
+        return exitCode;
+    prompts.log("Applied the current .env settings.");
+    prompts.outro("Configure complete.");
+    return 0;
+};

package/dist/env.js

@@ -10,9 +10,10 @@
 // └─────────────────────────────────────────────────────────────────────────┘
 // sync:local-optional:begin
 const LOCAL_OPTIONAL_BLOCK = `# Optional ──────────────────────────────────────────────────
-# To change a setting: edit its value (uncommenting it first if needed),
-# then apply with "npx vault-cortex restart" (plain docker restart does
-# not re-read this file).
+# To change a setting: run "npx vault-cortex configure", or edit its
+# value here (uncommenting it first if needed) and apply with
+# "npx vault-cortex restart" (plain docker restart does not re-read
+# this file).
 
 # Public URL for OAuth issuer URL in discovery metadata (default: http://localhost:8000).
 # Override if you expose the server on a different URL (e.g. via a reverse proxy).
@@ -100,9 +101,10 @@ WINDOWS_MODE=false
 // └─────────────────────────────────────────────────────────────────────────┘
 // sync:remote-optional:begin
 const REMOTE_OPTIONAL_BLOCK = `# Optional ──────────────────────────────────────────────────
-# To change a setting: edit its value (uncommenting it first if needed),
-# then apply with "npx vault-cortex restart" (plain docker restart does
-# not re-read this file).
+# To change a setting: run "npx vault-cortex configure", or edit its
+# value here (uncommenting it first if needed) and apply with
+# "npx vault-cortex restart" (plain docker restart does not re-read
+# this file).
 
 # Your IANA timezone — affects daily note resolution and memory timestamps.
 # TZ=America/New_York

package/dist/init.js

@@ -1,8 +1,10 @@
+import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { buildLocalEnv, buildRemoteEnv } from "./env.js";
 import { captureObsidianToken } from "./get-sync-token.js";
 import { buildLocalConnectMessage, buildRemoteConnectMessage, } from "./messages.js";
 import { pollHealth } from "./docker.js";
+import { applyOptionalSettings, askOptionalSettings, derivePublicUrlOverride, } from "./optional-settings.js";
 import { buildFilesToWrite, readEnvPort, writeFiles, } from "./scaffold.js";
 import { generateToken } from "./token.js";
 import { expandTilde, validateVaultPath } from "./vault.js";
@@ -203,10 +205,25 @@ const runLocalInit = async (flags, deps) => {
                 placeholder: DEFAULT_TARGET_DIR,
             }))));
     const token = generateToken();
+    // Guided optional settings: the chooser reads current values from the
+    // generated defaults; enter with nothing picked keeps them all. --yes
+    // skips the chooser (non-interactive by contract), and so does an existing
+    // .env — the conflict prompt defaults to keeping it, which would discard
+    // the answers; settings on an existing deployment are configure's job.
+    const defaultEnvContent = buildLocalEnv({ mcpAuthToken: token, vaultPath });
+    const envAlreadyExists = existsSync(join(targetDir, ".env"));
+    const offerSettingsChooser = !flags.yes && !envAlreadyExists;
+    if (!flags.yes && envAlreadyExists) {
+        prompts.log('Found an existing .env — settings prompts skipped. Adjust settings with "npx vault-cortex configure".');
+    }
+    const optionalOverrides = offerSettingsChooser
+        ? await askOptionalSettings({ mode: "local", envContent: defaultEnvContent }, prompts)
+        : {};
+    const envContent = applyOptionalSettings(defaultEnvContent, derivePublicUrlOverride(defaultEnvContent, optionalOverrides));
     // Conflict policy: identical existing files are skipped silently;
     // differing ones prompt per file (default keep). --yes never overwrites —
     // any differing file becomes an exit-1 below, leaving it untouched.
-    const files = buildFilesToWrite(buildLocalEnv({ mcpAuthToken: token, vaultPath }));
+    const files = buildFilesToWrite(envContent);
     const resolveConflict = flags.yes ? keepExisting : confirmOverwrite(prompts);
     const results = await writeFiles({ targetDir, files }, resolveConflict);
     reportWrites({ targetDir, results }, prompts);
@@ -262,13 +279,24 @@ const runRemoteInit = async (flags, deps) => {
         ? await prompts.password("Vault encryption password:")
         : undefined;
     const token = generateToken();
-    const envContent = buildRemoteEnv({
+    // Guided optional settings, mirroring the local flow — remote also offers
+    // SYNC_MODE. Remote init is always interactive (no --yes), so only an
+    // existing .env skips the chooser here.
+    const defaultEnvContent = buildRemoteEnv({
         mcpAuthToken: token,
         publicUrl,
         obsidianAuthToken,
         vaultName,
         vaultPassword,
     });
+    const envAlreadyExists = existsSync(join(targetDir, ".env"));
+    if (envAlreadyExists) {
+        prompts.log('Found an existing .env — settings prompts skipped. Adjust settings with "npx vault-cortex configure".');
+    }
+    const optionalOverrides = envAlreadyExists
+        ? {}
+        : await askOptionalSettings({ mode: "remote", envContent: defaultEnvContent }, prompts);
+    const envContent = applyOptionalSettings(defaultEnvContent, derivePublicUrlOverride(defaultEnvContent, optionalOverrides));
     const files = buildFilesToWrite(envContent);
     const results = await writeFiles({ targetDir, files }, confirmOverwrite(prompts));
     reportWrites({ targetDir, results }, prompts);

package/dist/lifecycle.js

@@ -8,7 +8,7 @@ const DEFAULT_TARGET_DIR = "./vault-cortex";
  * starting a container: resolves --dir and confirms an init'd .env exists.
  * Full start-readiness validation lives in resolveDeployment.
  */
-const requireInitializedDir = (dirFlag, prompts) => {
+export const requireInitializedDir = (dirFlag, prompts) => {
     const targetDir = resolve(expandTilde(dirFlag ?? DEFAULT_TARGET_DIR));
     const envFilePath = join(targetDir, ".env");
     const mode = detectMode(envFilePath);

package/dist/main.js

@@ -1,3 +1,4 @@
+import { runConfigure } from "./configure.js";
 import { createDockerRunner } from "./docker.js";
 import { runGetSyncToken } from "./get-sync-token.js";
 import { runInit } from "./init.js";
@@ -13,6 +14,11 @@ export const run = async (version) => {
             docker: createDockerRunner(),
             fetchFn: fetch,
         }),
+        runConfigure: (flags) => runConfigure(flags, {
+            prompts: createPrompts(),
+            docker: createDockerRunner(),
+            fetchFn: fetch,
+        }),
         runUpgrade: (flags) => runUpgrade(flags, {
             prompts: createPrompts(),
             docker: createDockerRunner(),

package/dist/messages.js

@@ -110,10 +110,13 @@ ${smokeTest(`${baseUrl}/healthz`)}
 
 ${sectionRule("Settings")}
 
-Optional settings (timezone, memory folder, port, logging) live in
-${targetDir}/.env — edit a value (uncommenting it first if needed), then
-apply with "npx vault-cortex restart" (plain docker restart does not
-re-read .env).
+Adjust optional settings (memory layer and folder, file tools,
+semantic search, port, timezone):
+  npx vault-cortex configure --dir "${targetDir}"
+
+Or edit ${targetDir}/.env directly — change a value (uncommenting it
+first if needed), then apply with "npx vault-cortex restart" (plain
+docker restart does not re-read .env).
 
 ${updateGuidance(targetDir)}
 
@@ -172,8 +175,11 @@ ${smokeTest(`${publicUrl}/healthz`)}
 
 ${sectionRule("Settings")}
 
-Optional settings (timezone, memory folder, port, logging, sync
-behavior) live in ${targetDir}/.env — edit a value (uncommenting it
+Adjust optional settings (memory layer and folder, file tools,
+semantic search, port, timezone, sync direction):
+  npx vault-cortex configure --dir "${targetDir}"
+
+Or edit ${targetDir}/.env directly — change a value (uncommenting it
 first if needed), then apply with "npx vault-cortex restart" (plain
 docker restart does not re-read .env).
 

package/dist/optional-settings.js

@@ -0,0 +1,233 @@
+import { DEFAULT_PORT } from "./scaffold.js";
+// 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.
+const OPTIONAL_SETTINGS = [
+    {
+        kind: "toggle",
+        name: "MEMORY_ENABLED",
+        label: "Memory layer",
+        question: "Enable the memory layer (About Me/ folder + memory tools)?",
+    },
+    {
+        kind: "folder",
+        name: "MEMORY_DIR",
+        label: "Memory folder",
+        question: "Vault folder for the memory files:",
+        defaultValue: "About Me",
+        requiresToggle: "MEMORY_ENABLED",
+    },
+    {
+        kind: "toggle",
+        name: "FILE_TOOLS_ENABLED",
+        label: "File tools",
+        question: "Enable file tools (read images, PDFs, and other non-Markdown files)?",
+    },
+    {
+        kind: "toggle",
+        name: "EMBEDDING_ENABLED",
+        label: "Semantic search",
+        question: "Enable semantic search embeddings (richer search, slower first startup)?",
+    },
+    { kind: "port", name: "PORT", label: "Host port" },
+    { kind: "timezone", name: "TZ", label: "Timezone" },
+    {
+        kind: "choice",
+        name: "SYNC_MODE",
+        label: "Sync direction",
+        question: "Obsidian Sync direction:",
+        choices: [
+            {
+                value: "bidirectional",
+                label: "Bidirectional",
+                hint: "pull remote changes and push server-side edits",
+            },
+            {
+                value: "pull-only",
+                label: "Pull-only",
+                hint: "receive changes but never push",
+            },
+            {
+                value: "push-only",
+                label: "Push-only",
+                hint: "push changes but never pull",
+            },
+        ],
+        defaultValue: "bidirectional",
+        remoteOnly: true,
+    },
+];
+/** Matches the full active (uncommented) assignment line for a var. */
+const activeLinePattern = (name) => new RegExp(`^${name}=.*$`, "m");
+/** Matches the full commented-out assignment line (`# VAR=...`) for a var. */
+const commentedLinePattern = (name) => new RegExp(`^# ${name}=.*$`, "m");
+/**
+ * Reads a var's current value from .env content. A commented-out or missing
+ * line returns undefined — both mean "the server uses its built-in default",
+ * which is exactly what the prompts need to distinguish. Duplicate lines
+ * report the LAST value, matching docker --env-file precedence — hints,
+ * prompt seeding, and the PUBLIC_URL derivation must reason from the value
+ * that actually takes effect.
+ */
+export const readOptionalValue = (envContent, name) => {
+    const matches = [...envContent.matchAll(new RegExp(`^${name}=(.*)$`, "gm"))];
+    return matches.at(-1)?.[1].trim();
+};
+/**
+ * Applies chosen values to .env content as a pure text transform: every
+ * active line for the var is replaced (docker --env-file gives the last
+ * duplicate precedence, so a single-line replace could leave a stale
+ * duplicate winning), a commented-out line is uncommented and replaced, and
+ * a var with no line at all (a .env predating the setting) is appended —
+ * the chosen value must land in the file, never be silently dropped.
+ */
+export const applyOptionalSettings = (envContent, overrides) => Object.entries(overrides).reduce((content, [name, value]) => {
+    // Fresh RegExp per use (the /g flag makes instances stateful via
+    // lastIndex); function replacements avoid $-pattern interpretation in
+    // values, same as patchEnvObsidianToken.
+    const everyActiveLine = new RegExp(`^${name}=.*$`, "gm");
+    if (activeLinePattern(name).test(content)) {
+        return content.replace(everyActiveLine, () => `${name}=${value}`);
+    }
+    if (commentedLinePattern(name).test(content)) {
+        return content.replace(commentedLinePattern(name), () => `${name}=${value}`);
+    }
+    return `${content.trimEnd()}\n\n${name}=${value}\n`;
+}, envContent);
+/**
+ * A PORT override moves the server, and the local quickstart derives
+ * PUBLIC_URL (the OAuth issuer) from that port. When the current PUBLIC_URL
+ * is exactly the derived http://localhost:<current port> form, it follows
+ * the new port — otherwise the advertised OAuth discovery endpoints would
+ * point at a port nothing listens on. A custom PUBLIC_URL (reverse proxy,
+ * remote domain) is the user's own and is never touched.
+ */
+export const derivePublicUrlOverride = (envContent, overrides) => {
+    const newPort = overrides.PORT;
+    if (!newPort)
+        return overrides;
+    const currentPort = readOptionalValue(envContent, "PORT") ?? String(DEFAULT_PORT);
+    const currentPublicUrl = readOptionalValue(envContent, "PUBLIC_URL");
+    if (currentPublicUrl !== `http://localhost:${currentPort}`)
+        return overrides;
+    return { ...overrides, PUBLIC_URL: `http://localhost:${newPort}` };
+};
+/**
+ * The .env spellings the server reads as "off" — env-var's asBool accepts
+ * 0/1 alongside true/false. An absent or unrecognized value falls to the
+ * server default, which is enabled for every curated toggle.
+ */
+const isDisabledToggleValue = (value) => ["false", "0"].includes((value ?? "").toLowerCase());
+/**
+ * Plain digits in the TCP port range. Number() coercion is not enough:
+ * it accepts "1e4"/"0x1F40"/"+9000", which readEnvPort's /^PORT=(\d+)/
+ * would later fail to read back — silently falling to the default port.
+ */
+const isValidPort = (value) => {
+    if (!/^\d+$/.test(value))
+        return false;
+    const port = Number(value);
+    return port >= 1 && port <= 65535;
+};
+/**
+ * The engine's own IANA zone validation: Intl.DateTimeFormat throws a
+ * RangeError for an unknown timeZone, so no hand-rolled zone list to drift.
+ */
+const isValidTimezone = (value) => {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: value });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/** Re-prompts until the answer is a valid port number. */
+const askPort = async (currentValue, prompts) => {
+    const answer = (await prompts.text("Host port for the server:", {
+        defaultValue: currentValue ?? String(DEFAULT_PORT),
+        placeholder: String(DEFAULT_PORT),
+    })).trim();
+    if (isValidPort(answer))
+        return answer;
+    prompts.error("PORT must be a whole number between 1 and 65535.");
+    return askPort(currentValue, prompts);
+};
+/** Re-prompts until the answer is a zone the runtime recognizes. */
+const askTimezone = async (currentValue, prompts) => {
+    const answer = (await prompts.text("Your IANA timezone:", {
+        defaultValue: currentValue,
+        placeholder: "America/New_York",
+    })).trim();
+    if (answer !== "" && isValidTimezone(answer))
+        return answer;
+    prompts.error(`"${answer}" is not a recognized IANA timezone (e.g. America/New_York, Europe/London).`);
+    return askTimezone(currentValue, prompts);
+};
+/** Re-prompts until the answer is a non-empty folder name. */
+const askFolder = async (params, prompts) => {
+    const { question, currentValue, defaultValue } = params;
+    const answer = (await prompts.text(question, {
+        defaultValue: currentValue ?? defaultValue,
+        placeholder: defaultValue,
+    })).trim();
+    if (answer !== "")
+        return answer;
+    prompts.error("The folder name can't be empty.");
+    return askFolder(params, prompts);
+};
+/** Routes a picked setting to its kind's prompt and returns the .env value. */
+const askSettingValue = async (params, prompts) => {
+    const { setting, currentValue } = params;
+    switch (setting.kind) {
+        case "toggle": {
+            const enabled = await prompts.confirm(setting.question, !isDisabledToggleValue(currentValue));
+            return String(enabled);
+        }
+        case "port":
+            return askPort(currentValue, prompts);
+        case "timezone":
+            return askTimezone(currentValue, prompts);
+        case "folder":
+            return askFolder({
+                question: setting.question,
+                currentValue,
+                defaultValue: setting.defaultValue,
+            }, prompts);
+        case "choice":
+            return prompts.select(setting.question, setting.choices, currentValue ?? setting.defaultValue);
+    }
+};
+/**
+ * The guided optional-settings flow shared by init and configure: one
+ * multiselect chooser (enter with nothing picked = change nothing), then one
+ * prompt per picked setting. Returns the chosen values keyed by var name —
+ * the caller owns applying them via applyOptionalSettings.
+ */
+export const askOptionalSettings = async (params, prompts) => {
+    const { mode, envContent } = params;
+    const offeredSettings = OPTIONAL_SETTINGS.filter((setting) => !setting.remoteOnly || mode === "remote");
+    const chooserOptions = offeredSettings.map((setting) => {
+        const currentValue = readOptionalValue(envContent, setting.name);
+        const requiredToggle = OPTIONAL_SETTINGS.find((candidate) => candidate.name === setting.requiresToggle);
+        const dependencyNote = requiredToggle &&
+            isDisabledToggleValue(readOptionalValue(envContent, requiredToggle.name))
+            ? ` · not used while ${requiredToggle.label} is off`
+            : "";
+        return {
+            value: setting.name,
+            label: setting.label,
+            hint: `${setting.name} · currently ${currentValue || "not set"}${dependencyNote}`,
+        };
+    });
+    const pickedNames = await prompts.multiselect("Any optional settings to change? (press enter to skip)", chooserOptions);
+    // Sequential prompting: answers are gathered one at a time in the curated
+    // order, so the record builds up inside an honest loop.
+    const overrides = {};
+    for (const setting of offeredSettings) {
+        if (!pickedNames.includes(setting.name))
+            continue;
+        overrides[setting.name] = await askSettingValue({ setting, currentValue: readOptionalValue(envContent, setting.name) }, prompts);
+    }
+    return overrides;
+};

package/dist/program.js

@@ -15,6 +15,13 @@ export const buildProgram = (options) => {
         .action(async (flags) => {
         process.exitCode = await options.runInit(flags);
     });
+    program
+        .command("configure")
+        .description("Change optional settings interactively and restart to apply them")
+        .option("--dir <path>", "directory containing .env (default: ./vault-cortex)")
+        .action(async (flags) => {
+        process.exitCode = await options.runConfigure(flags);
+    });
     program
         .command("upgrade")
         .description("Pull the latest image, re-create the container, and verify health")

package/dist/prompts.js

@@ -28,6 +28,9 @@ export const createPrompts = () => ({
     warn: (message) => clack.log.warn(message),
     error: (message) => clack.log.error(message),
     select: async (message, options, initialValue) => exitOnCancel(await clack.select({ message, options, initialValue })),
+    // required: false makes an empty submission legal — the Prompts contract
+    // promises "no picks" resolves to [] instead of a re-prompt loop.
+    multiselect: async (message, options) => exitOnCancel(await clack.multiselect({ message, options, required: false })),
     text: async (message, options = {}) => exitOnCancel(await clack.text({
         message,
         placeholder: options.placeholder,

package/package.json

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