virlow-mcp 3.11.4

package/dist/cli.js

@@ -0,0 +1,2030 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as os2 from "node:os";
+import * as path4 from "node:path";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../../packages/mcp-core/dist/api.js
+var ApiError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+};
+var VirlowApi = class {
+  baseUrl;
+  tokens = null;
+  refreshInFlight = null;
+  onTokensRotated;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  setTokens(tokens) {
+    this.tokens = tokens;
+  }
+  async request(method, path5, body, opts = {}) {
+    const { auth = true, retryOn401 = true } = opts;
+    const headers = { "content-type": "application/json" };
+    if (auth && this.tokens)
+      headers.authorization = `Bearer ${this.tokens.accessToken}`;
+    const res = await fetch(`${this.baseUrl}${path5}`, {
+      method,
+      headers,
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+    if (res.status === 401 && auth && retryOn401 && this.tokens) {
+      await this.refresh();
+      return this.request(method, path5, body, { auth, retryOn401: false });
+    }
+    if (res.status === 204)
+      return void 0;
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      const d = data;
+      throw new ApiError(res.status, d.error ?? d.message ?? res.statusText);
+    }
+    return data;
+  }
+  refresh() {
+    this.refreshInFlight ??= this.doRefresh().finally(() => {
+      this.refreshInFlight = null;
+    });
+    return this.refreshInFlight;
+  }
+  async doRefresh() {
+    if (!this.tokens)
+      throw new ApiError(401, "Not authenticated");
+    const rotated = await this.request("POST", "/api/auth/refresh", { refreshToken: this.tokens.refreshToken }, { auth: false, retryOn401: false });
+    this.tokens = { accessToken: rotated.accessToken, refreshToken: rotated.refreshToken };
+    this.onTokensRotated?.(this.tokens);
+  }
+  login(email, password) {
+    return this.request("POST", "/api/auth/login", { email, password }, { auth: false });
+  }
+  verify2fa(mfaToken, codeOrRecovery) {
+    return this.request("POST", "/api/auth/2fa/verify", { mfaToken, ...codeOrRecovery }, { auth: false });
+  }
+  me() {
+    return this.request("GET", "/api/users/me");
+  }
+  encryptionStatus() {
+    return this.request("GET", "/api/users/me/encryption");
+  }
+  listNotes(params) {
+    const query = new URLSearchParams();
+    if (params.page !== void 0)
+      query.set("page", String(params.page));
+    if (params.limit !== void 0)
+      query.set("limit", String(params.limit));
+    if (params.folderId !== void 0)
+      query.set("folderId", params.folderId);
+    if (params.starred !== void 0)
+      query.set("starred", String(params.starred));
+    if (params.archived !== void 0)
+      query.set("archived", String(params.archived));
+    if (params.deleted !== void 0)
+      query.set("deleted", String(params.deleted));
+    const qs = query.toString();
+    return this.request("GET", `/api/notes${qs ? `?${qs}` : ""}`);
+  }
+  getNote(id) {
+    return this.request("GET", `/api/notes/${id}`);
+  }
+  createNote(body) {
+    return this.request("POST", "/api/notes", body);
+  }
+  updateNote(id, body) {
+    return this.request("PUT", `/api/notes/${id}`, body);
+  }
+  listFolders() {
+    return this.request("GET", "/api/folders");
+  }
+  createFolder(name, parentId, kind) {
+    const body = {
+      name,
+      parentId
+    };
+    if (kind !== void 0)
+      body.kind = kind;
+    return this.request("POST", "/api/folders", body);
+  }
+};
+
+// ../../packages/mcp-core/dist/vault.js
+var LockedError = class extends Error {
+};
+var Vault = class {
+  autoLockMs;
+  _session = null;
+  _timerHandle = null;
+  /** Listeners registered via `onLock =` or `addLockListener()`. Multiple
+   * consumers (MemoryStore, NotesService, ...) each need their cache cleared
+   * on lock; a single-slot callback would let the second registration
+   * silently clobber the first. */
+  lockListeners = [];
+  constructor(autoLockMs = 4 * 60 * 60 * 1e3) {
+    this.autoLockMs = autoLockMs;
+  }
+  /** Alias for `addLockListener` kept for call-site brevity (`vault.onLock = fn`).
+   * Assigning multiple times ADDS a listener each time — it does not replace
+   * a previous one. */
+  set onLock(fn) {
+    this.addLockListener(fn);
+  }
+  addLockListener(fn) {
+    this.lockListeners.push(fn);
+  }
+  setUnlocked(session) {
+    this._session = session;
+    this._scheduleAutoLock();
+  }
+  lock() {
+    if (this._session === null) {
+      return;
+    }
+    this._clearTimer();
+    this._session = null;
+    for (const listener of this.lockListeners) {
+      listener();
+    }
+  }
+  isUnlocked() {
+    return this._session !== null;
+  }
+  status() {
+    if (this._session === null) {
+      return { locked: true };
+    }
+    return { locked: false, email: this._session.email };
+  }
+  touch() {
+    if (this._session === null) {
+      return;
+    }
+    this._clearTimer();
+    this._scheduleAutoLock();
+  }
+  get session() {
+    if (this._session === null) {
+      throw new LockedError("Vault is locked. Ask the user to run the unlock tool to sign in and unlock their Virlow vault.");
+    }
+    return this._session;
+  }
+  _scheduleAutoLock() {
+    this._timerHandle = setTimeout(() => {
+      this.lock();
+    }, this.autoLockMs);
+    this._timerHandle.unref?.();
+  }
+  _clearTimer() {
+    if (this._timerHandle !== null) {
+      clearTimeout(this._timerHandle);
+      this._timerHandle = null;
+    }
+  }
+};
+
+// ../../packages/crypto/dist/base64.js
+var CHUNK_SIZE = 32768;
+function bytesToBase64(input) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const chunks = [];
+  for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
+    const chunk = bytes.subarray(i, Math.min(i + CHUNK_SIZE, bytes.length));
+    chunks.push(String.fromCharCode.apply(null, Array.from(chunk)));
+  }
+  return btoa(chunks.join(""));
+}
+function base64ToBytes(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function base64ToArrayBuffer(base64) {
+  const bytes = base64ToBytes(base64);
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+
+// ../../packages/crypto/dist/constants.js
+var ENCRYPTION_CONFIG = {
+  ALGORITHM: "AES-GCM",
+  KEY_LENGTH: 256,
+  IV_LENGTH: 16,
+  ITERATIONS: 25e4,
+  SALT_LENGTH: 32
+};
+var VERIFIER_CONSTANT = "virlow-mp-verifier-v1";
+
+// ../../packages/crypto/dist/blob.js
+async function encryptBytesBlob(key, bytes) {
+  const iv = crypto.getRandomValues(new Uint8Array(ENCRYPTION_CONFIG.IV_LENGTH));
+  const ciphertext = await crypto.subtle.encrypt({ name: ENCRYPTION_CONFIG.ALGORITHM, iv }, key, bytes);
+  return "v2:" + bytesToBase64(iv) + ":" + bytesToBase64(ciphertext);
+}
+async function decryptBytesBlob(key, blob) {
+  if (!blob.startsWith("v2:")) {
+    throw new Error("Malformed encrypted blob: missing v2 prefix");
+  }
+  const rest = blob.slice(3);
+  const sep = rest.indexOf(":");
+  if (sep === -1) {
+    throw new Error("Malformed encrypted blob: missing IV separator");
+  }
+  const iv = base64ToBytes(rest.slice(0, sep));
+  const decrypted = await crypto.subtle.decrypt({ name: ENCRYPTION_CONFIG.ALGORITHM, iv }, key, base64ToArrayBuffer(rest.slice(sep + 1)));
+  return new Uint8Array(decrypted);
+}
+
+// ../../packages/crypto/dist/keys.js
+async function deriveMasterKey(masterPassword, userId) {
+  if (!userId) {
+    throw new Error("deriveMasterKey requires a userId");
+  }
+  const encoder = new TextEncoder();
+  const passwordBytes = typeof masterPassword === "string" ? encoder.encode(masterPassword) : masterPassword;
+  const userSalt = encoder.encode(`typelets-salt-${userId}-v1`);
+  const keyMaterial = await crypto.subtle.importKey("raw", passwordBytes, { name: "PBKDF2" }, false, ["deriveKey"]);
+  const key = await crypto.subtle.deriveKey({
+    name: "PBKDF2",
+    salt: userSalt,
+    iterations: ENCRYPTION_CONFIG.ITERATIONS,
+    hash: "SHA-256"
+  }, keyMaterial, {
+    name: ENCRYPTION_CONFIG.ALGORITHM,
+    length: ENCRYPTION_CONFIG.KEY_LENGTH
+  }, true, ["encrypt", "decrypt"]);
+  const exportedKey = await crypto.subtle.exportKey("raw", key);
+  return { key, keyString: bytesToBase64(new Uint8Array(exportedKey)) };
+}
+async function importMasterKey(keyString) {
+  const keyData = base64ToBytes(keyString);
+  return crypto.subtle.importKey("raw", keyData, { name: ENCRYPTION_CONFIG.ALGORITHM }, false, ["encrypt", "decrypt"]);
+}
+
+// ../../packages/crypto/dist/notes.js
+async function encryptNoteFields(key, title, content) {
+  const ivTitle = crypto.getRandomValues(new Uint8Array(ENCRYPTION_CONFIG.IV_LENGTH));
+  const ivContent = crypto.getRandomValues(new Uint8Array(ENCRYPTION_CONFIG.IV_LENGTH));
+  const encoder = new TextEncoder();
+  const encryptedTitleBuffer = await crypto.subtle.encrypt({ name: ENCRYPTION_CONFIG.ALGORITHM, iv: ivTitle }, key, encoder.encode(title || ""));
+  const encryptedContentBuffer = await crypto.subtle.encrypt({ name: ENCRYPTION_CONFIG.ALGORITHM, iv: ivContent }, key, encoder.encode(content || ""));
+  return {
+    encryptedTitle: bytesToBase64(encryptedTitleBuffer),
+    encryptedContent: "v2:" + bytesToBase64(ivContent) + ":" + bytesToBase64(encryptedContentBuffer),
+    iv: bytesToBase64(ivTitle)
+  };
+}
+async function decryptNoteFields(key, encryptedTitle, encryptedContent, ivBase64) {
+  const ivTitle = base64ToBytes(ivBase64);
+  let ivContent = ivTitle;
+  let contentCipher = encryptedContent;
+  if (encryptedContent.startsWith("v2:")) {
+    const rest = encryptedContent.slice(3);
+    const sep = rest.indexOf(":");
+    ivContent = base64ToBytes(rest.slice(0, sep));
+    contentCipher = rest.slice(sep + 1);
+  }
+  const decryptedTitleBuffer = await crypto.subtle.decrypt({ name: ENCRYPTION_CONFIG.ALGORITHM, iv: ivTitle }, key, base64ToArrayBuffer(encryptedTitle));
+  const decryptedContentBuffer = await crypto.subtle.decrypt({ name: ENCRYPTION_CONFIG.ALGORITHM, iv: ivContent }, key, base64ToArrayBuffer(contentCipher));
+  const decoder = new TextDecoder();
+  return {
+    title: decoder.decode(decryptedTitleBuffer),
+    content: decoder.decode(decryptedContentBuffer)
+  };
+}
+
+// ../../packages/crypto/dist/verifier.js
+async function verifyVerifierBlob(key, blob) {
+  try {
+    const iv = base64ToBytes(blob.iv);
+    const decrypted = await crypto.subtle.decrypt({ name: ENCRYPTION_CONFIG.ALGORITHM, iv }, key, base64ToArrayBuffer(blob.ciphertext));
+    return new TextDecoder().decode(decrypted) === VERIFIER_CONSTANT;
+  } catch {
+    return false;
+  }
+}
+async function canDecryptWithKey(key, ciphertextBase64, ivBase64) {
+  try {
+    const iv = base64ToBytes(ivBase64);
+    await crypto.subtle.decrypt({ name: ENCRYPTION_CONFIG.ALGORITHM, iv }, key, base64ToArrayBuffer(ciphertextBase64));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../../packages/mcp-core/dist/exposure.js
+function computeExposure(folders, opts = {}) {
+  const byId = new Map(folders.map((f) => [f.id, f]));
+  const memoriesRootId = opts.memoriesRootId ?? folders.find((f) => f.kind === "memories")?.id ?? null;
+  const resolved = /* @__PURE__ */ new Map();
+  const isExposed = (folderId) => {
+    const cached = resolved.get(folderId);
+    if (cached !== void 0)
+      return cached;
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current = folderId;
+    let exposed = false;
+    while (current !== null && !seen.has(current)) {
+      seen.add(current);
+      const folder = byId.get(current);
+      if (folder === void 0)
+        break;
+      chain.push(folder.id);
+      if (folder.mcpEnabled === true || folder.id === memoriesRootId) {
+        exposed = true;
+        break;
+      }
+      current = folder.parentId;
+    }
+    for (const id of chain)
+      resolved.set(id, exposed);
+    return exposed;
+  };
+  let hiddenFolderCount = 0;
+  for (const folder of folders) {
+    if (!isExposed(folder.id))
+      hiddenFolderCount++;
+  }
+  return {
+    // A note in no folder is in nothing the user has opened, so it stays
+    // hidden. That is consistent with off-by-default, and the tools say so
+    // rather than letting it look like the note is gone.
+    allows: (folderId) => folderId === null ? false : isExposed(folderId),
+    hiddenFolderCount,
+    allHidden: folders.length > 0 && hiddenFolderCount === folders.length
+  };
+}
+function filteredNotice(hidden, exposure) {
+  const parts = [];
+  if (hidden.inClosedFolders > 0) {
+    const n = hidden.inClosedFolders;
+    const notes = `${n} note${n === 1 ? "" : "s"}`;
+    parts.push(exposure.allHidden ? `${notes} hidden: no folder is exposed to MCP yet. Open a folder in the Virlow app, edit it, and turn on "Expose to MCP" to let AI tools read it.` : `${notes} hidden in folders that are not exposed to MCP. Turn on "Expose to MCP" in a folder's settings in the Virlow app to include it.`);
+  }
+  if (hidden.unfiled > 0) {
+    const n = hidden.unfiled;
+    parts.push(`${n} note${n === 1 ? "" : "s"} hidden because ${n === 1 ? "it is" : "they are"} not in any folder, and exposure is granted per folder. Move ${n === 1 ? "it" : "them"} into a folder that is exposed to MCP to include ${n === 1 ? "it" : "them"}.`);
+  }
+  return parts.length === 0 ? "" : `
+
+(${parts.join(" ")})`;
+}
+
+// ../../packages/mcp-core/dist/notes.js
+var SEARCH_SCAN_CAP = 500;
+var SEARCH_PAGE_LIMIT = 50;
+var SNIPPET_RADIUS = 80;
+var NotesService = class {
+  api;
+  vault;
+  /** Per-unlock cache of decrypted (title, content) keyed by `id:updatedAt`
+   * so re-reading/re-scanning the same note twice in one unlock doesn't
+   * re-run AES-GCM decryption. Cleared whenever the vault locks. */
+  decryptCache = /* @__PURE__ */ new Map();
+  /** Bumped every time the vault locks (see handleLock()). decryptRow()
+   * captures this before its await on decryptNoteFields() and re-checks it
+   * afterward, so a decrypt that was still in flight when the vault locked
+   * never writes decrypted plaintext into the cache after the lock. */
+  epoch = 0;
+  /** Serializes updateNote() calls so two overlapping partial edits to the
+   * same note (e.g. one changing title, one changing content) never race
+   * their read-merge-encrypt-write cycle — without this, both could read
+   * the same pre-edit row and the second write would silently clobber the
+   * first's change. Mirrors MemoryStore's enqueue()/mutationChain pattern. */
+  mutationChain = Promise.resolve();
+  constructor(api, vault) {
+    this.api = api;
+    this.vault = vault;
+    this.vault.onLock = () => this.handleLock();
+  }
+  handleLock() {
+    this.decryptCache.clear();
+    this.epoch++;
+  }
+  async listNotes(params) {
+    const key = this.requireSession();
+    const { notes, pagination } = await this.api.listNotes({ ...params, deleted: false });
+    const exposure = await this.exposure();
+    const notHidden = notes.filter((row) => row.hidden !== true);
+    const visible = notHidden.filter((row) => exposure.allows(row.folderId));
+    const withheld = {
+      inClosedFolders: notHidden.filter((row) => row.folderId !== null && !exposure.allows(row.folderId)).length,
+      unfiled: notHidden.filter((row) => row.folderId === null).length
+    };
+    const mapped = await Promise.all(visible.map(async (row) => {
+      const { title } = await this.decryptRow(key, row);
+      return {
+        id: row.id,
+        title,
+        folderId: row.folderId,
+        starred: row.starred === true,
+        updatedAt: row.updatedAt
+      };
+    }));
+    return { notes: mapped, pagination, withheld, exposure };
+  }
+  async readNote(id) {
+    const key = this.requireSession();
+    const row = await this.api.getNote(id);
+    const exposure = await this.exposure();
+    if (!exposure.allows(row.folderId)) {
+      throw new Error(`Note ${id} is in a folder that is not exposed to MCP. Turn on "Expose to MCP" in that folder's settings in the Virlow app to read it here.`);
+    }
+    const { title, content } = await this.decryptRow(key, row);
+    return { id: row.id, title, content, folderId: row.folderId };
+  }
+  async createNote(title, content, folderId, type) {
+    const key = this.requireSession();
+    const salt = bytesToBase64(crypto.getRandomValues(new Uint8Array(32)));
+    const { encryptedTitle, encryptedContent, iv } = await encryptNoteFields(key, title, content);
+    const body = {
+      title: "[ENCRYPTED]",
+      content: "[ENCRYPTED]",
+      encryptedTitle,
+      encryptedContent,
+      iv,
+      salt
+    };
+    if (folderId !== void 0)
+      body.folderId = folderId;
+    if (type !== void 0)
+      body.type = type;
+    const row = await this.api.createNote(body);
+    return { id: row.id };
+  }
+  updateNote(id, changes) {
+    return this.enqueue(async () => {
+      const key = this.requireSession();
+      const existingRow = await this.api.getNote(id);
+      const current = await this.decryptRow(key, existingRow);
+      const title = changes.title ?? current.title;
+      const content = changes.content ?? current.content;
+      const salt = bytesToBase64(crypto.getRandomValues(new Uint8Array(32)));
+      const { encryptedTitle, encryptedContent, iv } = await encryptNoteFields(key, title, content);
+      await this.api.updateNote(id, {
+        title: "[ENCRYPTED]",
+        content: "[ENCRYPTED]",
+        encryptedTitle,
+        encryptedContent,
+        iv,
+        salt
+      });
+    });
+  }
+  async searchNotes(query, limit = 20) {
+    const key = this.requireSession();
+    const q = query.toLowerCase();
+    const results = [];
+    let scanned = 0;
+    let total = 0;
+    let page = 1;
+    scan: for (; ; ) {
+      const { notes, pagination } = await this.api.listNotes({ page, limit: SEARCH_PAGE_LIMIT, deleted: false });
+      total = pagination.total;
+      for (const row of notes) {
+        if (row.hidden === true)
+          continue;
+        if (scanned >= SEARCH_SCAN_CAP)
+          break scan;
+        scanned++;
+        const { title, content } = await this.decryptRow(key, row);
+        const contentIdx = content.toLowerCase().indexOf(q);
+        const titleMatch = title.toLowerCase().includes(q);
+        if (titleMatch || contentIdx !== -1) {
+          results.push({ id: row.id, title, snippet: this.buildSnippet(title, content, contentIdx) });
+        }
+      }
+      if (scanned >= SEARCH_SCAN_CAP)
+        break;
+      if (notes.length === 0 || page >= pagination.pages)
+        break;
+      page++;
+    }
+    return { results: results.slice(0, limit), scanned, truncated: total > SEARCH_SCAN_CAP };
+  }
+  async moveNote(id, folderId) {
+    this.requireSession();
+    await this.api.updateNote(id, { folderId });
+  }
+  async setStar(id, starred) {
+    this.requireSession();
+    await this.api.updateNote(id, { starred });
+  }
+  async archiveNote(id, archived) {
+    this.requireSession();
+    await this.api.updateNote(id, { archived });
+  }
+  async trashNote(id) {
+    this.requireSession();
+    await this.api.updateNote(id, { deleted: true });
+  }
+  async listFolders() {
+    this.requireSession();
+    const { folders } = await this.api.listFolders();
+    const exposure = computeExposure(folders);
+    const visible = folders.filter((f) => exposure.allows(f.id));
+    return {
+      // Names are withheld along with contents: a folder the user has not
+      // opened should not be inventoried either, only counted.
+      folders: visible.map((f) => ({ id: f.id, name: f.name, parentId: f.parentId })),
+      withheld: folders.length - visible.length
+    };
+  }
+  /** Folder exposure for this request. Not cached across calls: the user can
+   * flip the switch in the app at any moment and the next tool call must
+   * respect it. */
+  async exposure() {
+    const { folders } = await this.api.listFolders();
+    return computeExposure(folders);
+  }
+  async createFolder(name, parentId) {
+    this.requireSession();
+    const folder = await this.api.createFolder(name, parentId);
+    return { id: folder.id };
+  }
+  /** Decrypt (with per-unlock caching) or pass through a legacy plaintext
+   * row. Legacy rows (no encryptedTitle) carry their real content directly
+   * in the plaintext title/content columns. */
+  async decryptRow(key, row) {
+    if (!row.encryptedTitle) {
+      return { title: row.title, content: row.content };
+    }
+    const cacheKey = `${row.id}:${row.updatedAt}`;
+    const cached = this.decryptCache.get(cacheKey);
+    if (cached)
+      return cached;
+    const startEpoch = this.epoch;
+    const fields = await decryptNoteFields(key, row.encryptedTitle, row.encryptedContent ?? "", row.iv ?? "");
+    if (this.epoch === startEpoch) {
+      this.decryptCache.set(cacheKey, fields);
+    }
+    return fields;
+  }
+  buildSnippet(title, content, contentMatchIndex) {
+    if (contentMatchIndex === -1) {
+      return title;
+    }
+    const windowSize = SNIPPET_RADIUS * 2;
+    let start = Math.max(0, contentMatchIndex - SNIPPET_RADIUS);
+    const end = Math.min(content.length, start + windowSize);
+    if (end - start < windowSize) {
+      start = Math.max(0, end - windowSize);
+    }
+    return content.slice(start, end);
+  }
+  requireSession() {
+    const key = this.vault.session.key;
+    this.vault.touch();
+    return key;
+  }
+  /** Chains `fn` onto the mutation queue so overlapping calls run one at a
+   * time; the `.catch(() => {})` guard keeps the internal chain alive after
+   * a rejection while the promise returned to the caller still carries it. */
+  enqueue(fn) {
+    const next = this.mutationChain.then(fn, fn);
+    this.mutationChain = next.catch(() => {
+    });
+    return next;
+  }
+};
+
+// ../../packages/memory-core/dist/constants.js
+var EMBEDDING_MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+var EMBEDDING_MODEL_REVISION = "751bff37182d3f1213fa05d7196b954e230abad9";
+var EMBEDDING_MODEL_TAG = "minilm-l6-v2@q8";
+var DEDUPE_UPDATE_THRESHOLD = 0.9;
+var DEDUPE_REPORT_THRESHOLD = 0.7;
+
+// ../../packages/memory-core/dist/vectors.js
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Embedding dimension mismatch: ${a.length} vs ${b.length}`);
+  }
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  if (normA === 0 || normB === 0)
+    return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function rankBySimilarity(query, entries, limit) {
+  return entries.map((e) => ({ id: e.id, similarity: cosineSimilarity(query, e.embedding) })).sort((x, y) => y.similarity - x.similarity).slice(0, limit);
+}
+function findDuplicate(embedding, entries, threshold = DEDUPE_UPDATE_THRESHOLD) {
+  const [best] = rankBySimilarity(embedding, entries, 1);
+  return best && best.similarity >= threshold ? best : null;
+}
+function findSimilar(embedding, entries, threshold = DEDUPE_REPORT_THRESHOLD) {
+  return rankBySimilarity(embedding, entries, entries.length).filter((e) => e.similarity >= threshold);
+}
+
+// ../../packages/memory-core/dist/embedder.js
+import { env, pipeline } from "@huggingface/transformers";
+async function createEmbedder(opts = {}) {
+  if (opts.cacheDir) {
+    env.cacheDir = opts.cacheDir;
+  }
+  if (opts.localModelPath) {
+    env.allowRemoteModels = false;
+    env.localModelPath = opts.localModelPath;
+  }
+  const extractor = await pipeline("feature-extraction", EMBEDDING_MODEL_ID, {
+    dtype: "q8",
+    revision: EMBEDDING_MODEL_REVISION
+  });
+  return {
+    async embed(text) {
+      const output = await extractor(text, { pooling: "mean", normalize: true });
+      return Float32Array.from(output.data);
+    }
+  };
+}
+
+// ../../packages/mcp-core/dist/memory-note.js
+import { parse as parseYaml } from "yaml";
+var KEY_ORDER = ["source", "tags", "confidence", "created"];
+var FENCE = "---";
+function toCodeEnvelope(body) {
+  return JSON.stringify({ language: "markdown", code: body, lastExecution: null });
+}
+function unwrapEnvelope(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed !== null && typeof parsed === "object" && typeof parsed.code === "string") {
+      return parsed.code;
+    }
+  } catch {
+  }
+  return content;
+}
+function coerceMeta(raw) {
+  const meta = {};
+  if (typeof raw.source === "string")
+    meta.source = raw.source;
+  if (Array.isArray(raw.tags) && raw.tags.every((t) => typeof t === "string")) {
+    meta.tags = [...raw.tags];
+  }
+  if (typeof raw.confidence === "string") {
+    meta.confidence = raw.confidence;
+  } else if (typeof raw.confidence === "number") {
+    meta.confidence = String(raw.confidence);
+  }
+  if (typeof raw.created === "string") {
+    meta.created = raw.created;
+  } else if (raw.created instanceof Date) {
+    meta.created = raw.created.toISOString();
+  }
+  return meta;
+}
+function parseMemoryNote(decryptedContent) {
+  const body = unwrapEnvelope(decryptedContent);
+  if (!body.startsWith(`${FENCE}
+`))
+    return { fact: body, meta: {} };
+  const close = body.indexOf(`
+${FENCE}
+`, FENCE.length);
+  if (close === -1)
+    return { fact: body, meta: {} };
+  const front = body.slice(FENCE.length + 1, close);
+  const fact = body.slice(close + FENCE.length + 2);
+  if (front.trim() === "")
+    return { fact, meta: {} };
+  let raw;
+  try {
+    raw = parseYaml(front);
+  } catch {
+    return { fact: body, meta: {} };
+  }
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    return { fact: body, meta: {} };
+  }
+  return { fact, meta: coerceMeta(raw) };
+}
+function yamlScalar(value) {
+  return /^[A-Za-z0-9][\w .:@/+-]*$/.test(value) && !value.includes(": ") ? value : JSON.stringify(value);
+}
+function serializeMemoryBody(fact, meta) {
+  const lines = [];
+  for (const key of KEY_ORDER) {
+    const value = meta[key];
+    if (value === void 0)
+      continue;
+    if (key === "tags") {
+      const tags = value;
+      if (tags.length === 0)
+        continue;
+      lines.push(`tags: [${tags.map(yamlScalar).join(", ")}]`);
+    } else {
+      lines.push(`${key}: ${yamlScalar(value)}`);
+    }
+  }
+  if (lines.length === 0) {
+    return fact.startsWith(`${FENCE}
+`) ? `${FENCE}
+${FENCE}
+${fact}` : fact;
+  }
+  return `${FENCE}
+${lines.join("\n")}
+${FENCE}
+${fact}`;
+}
+function mergeMeta(existing, changes) {
+  const merged = { ...existing };
+  if (changes.source !== void 0)
+    merged.source = changes.source;
+  if (changes.tags !== void 0)
+    merged.tags = [...changes.tags];
+  if (changes.confidence !== void 0)
+    merged.confidence = changes.confidence;
+  if (changes.created !== void 0 && existing.created === void 0) {
+    merged.created = changes.created;
+  }
+  return merged;
+}
+
+// ../../packages/mcp-core/dist/memory-tree.js
+var MEMORIES_ROOT_NAME = "Memories";
+function buildTree(rootId, folders) {
+  const namespaces = /* @__PURE__ */ new Map();
+  const byFolderId = /* @__PURE__ */ new Map();
+  const attach = (folderId, name) => {
+    byFolderId.set(folderId, name);
+    if (!namespaces.has(name))
+      namespaces.set(name, folderId);
+  };
+  for (const folder of folders) {
+    if (folder.parentId === rootId)
+      attach(folder.id, folder.name);
+  }
+  return {
+    rootId,
+    namespaces,
+    namespaceOf: (folderId) => byFolderId.get(folderId),
+    folderIds: () => [rootId, ...byFolderId.keys()],
+    attach
+  };
+}
+async function resolveMemoryTree(api) {
+  const { folders } = await api.listFolders();
+  const existing = folders.find((f) => f.kind === "memories");
+  if (existing)
+    return buildTree(existing.id, folders);
+  try {
+    const created = await api.createFolder(MEMORIES_ROOT_NAME, null, "memories");
+    return buildTree(created.id, [...folders, created]);
+  } catch (err) {
+    if (!(err instanceof ApiError) || err.status !== 409)
+      throw err;
+    const retry = await api.listFolders();
+    const winner = retry.folders.find((f) => f.kind === "memories");
+    if (!winner)
+      throw err;
+    return buildTree(winner.id, retry.folders);
+  }
+}
+async function ensureNamespace(api, tree, name) {
+  const existing = tree.namespaces.get(name);
+  if (existing)
+    return existing;
+  const created = await api.createFolder(name, tree.rootId);
+  tree.attach(created.id, name);
+  return created.id;
+}
+
+// ../../packages/mcp-core/dist/memories.js
+var SYNC_PAGE_LIMIT = 100;
+var round3 = (n) => Math.round(n * 1e3) / 1e3;
+var MemoryStore = class {
+  api;
+  vault;
+  embedder;
+  cacheFactory;
+  cache = /* @__PURE__ */ new Map();
+  tree = null;
+  embeddings = null;
+  embeddingsLoaded = false;
+  syncInFlight = null;
+  mutationChain = Promise.resolve();
+  /** Bumped every time clear() runs (i.e. every lock). Operations capture it
+   * at the top and re-check before every cache write, so anything still
+   * awaiting the network or a decrypt when the vault locked can never write
+   * decrypted plaintext back into a cache the user just emptied. */
+  epoch = 0;
+  constructor(api, vault, embedder, cacheFactory) {
+    this.api = api;
+    this.vault = vault;
+    this.embedder = embedder;
+    this.cacheFactory = cacheFactory;
+    this.vault.onLock = () => this.clear();
+  }
+  clear() {
+    this.cache.clear();
+    this.tree = null;
+    this.embeddings = null;
+    this.embeddingsLoaded = false;
+    this.epoch++;
+  }
+  get size() {
+    return this.cache.size;
+  }
+  /** Concurrent callers share one in-flight sync so two overlapping tool
+   * calls never double up on network, decrypt, or embedding work. */
+  sync() {
+    this.syncInFlight ??= this.doSync().finally(() => {
+      this.syncInFlight = null;
+    });
+    return this.syncInFlight;
+  }
+  async doSync() {
+    const key = this.requireSession();
+    const startEpoch = this.epoch;
+    const result = { added: 0, updated: 0, removed: 0, embedded: 0 };
+    const tree = await this.requireTree();
+    const embeddings = await this.requireEmbeddings(key);
+    const seen = /* @__PURE__ */ new Set();
+    for (const folderId of tree.folderIds()) {
+      let page = 1;
+      for (; ; ) {
+        let batch;
+        try {
+          batch = await this.api.listNotes({
+            folderId,
+            deleted: false,
+            page,
+            limit: SYNC_PAGE_LIMIT
+          });
+        } catch (err) {
+          if (err instanceof ApiError && err.status === 404) {
+            this.tree = null;
+            break;
+          }
+          throw err;
+        }
+        for (const row of batch.notes) {
+          if (row.hidden === true)
+            continue;
+          seen.add(row.id);
+          const existing = this.cache.get(row.id);
+          if (existing && existing.updatedAt === row.updatedAt) {
+            if (existing.folderId !== folderId) {
+              const moved = {
+                ...existing,
+                folderId,
+                ...namespaceField(tree.namespaceOf(folderId))
+              };
+              if (this.epoch === startEpoch)
+                this.cache.set(row.id, moved);
+              result.updated++;
+            }
+            continue;
+          }
+          const { title, content } = await this.decryptRow(key, row);
+          const { fact, meta } = parseMemoryNote(content);
+          let embedding = embeddings.get(row.id, row.updatedAt);
+          if (!embedding) {
+            embedding = await this.embedder.embed(embeddingInput(title, fact));
+            result.embedded++;
+          }
+          if (this.epoch !== startEpoch)
+            continue;
+          embeddings.set(row.id, row.updatedAt, embedding);
+          this.cache.set(row.id, {
+            id: row.id,
+            label: title,
+            text: fact,
+            meta,
+            folderId,
+            ...namespaceField(tree.namespaceOf(folderId)),
+            embedding,
+            updatedAt: row.updatedAt
+          });
+          if (existing)
+            result.updated++;
+          else
+            result.added++;
+        }
+        if (page >= batch.pagination.pages || batch.notes.length === 0)
+          break;
+        page++;
+      }
+    }
+    if (this.epoch === startEpoch) {
+      for (const id of [...this.cache.keys()]) {
+        if (seen.has(id))
+          continue;
+        this.cache.delete(id);
+        embeddings.delete(id);
+        result.removed++;
+      }
+      await embeddings.save(key);
+    }
+    return result;
+  }
+  add(label, text, namespace, meta = {}) {
+    return this.enqueue(async () => {
+      await this.sync();
+      const key = this.requireSession();
+      const startEpoch = this.epoch;
+      const embedding = await this.embedder.embed(embeddingInput(label, text));
+      const candidates = this.candidatesFor(namespace);
+      const hit = findDuplicate(embedding, candidates);
+      if (hit) {
+        const existing = this.cache.get(hit.id);
+        const merged = mergeMeta(existing.meta, meta);
+        const row2 = await this.writeNote(key, hit.id, label, text, merged);
+        if (this.epoch === startEpoch) {
+          this.cache.set(hit.id, {
+            ...existing,
+            label,
+            text,
+            meta: merged,
+            embedding,
+            updatedAt: row2.updatedAt
+          });
+          this.embeddings?.set(hit.id, row2.updatedAt, embedding);
+          await this.saveEmbeddings(key, startEpoch);
+        }
+        return { action: "updated", id: hit.id, similar: [] };
+      }
+      const tree = await this.requireTree();
+      const folderId = namespace !== void 0 ? await ensureNamespace(this.api, tree, namespace) : tree.rootId;
+      const stamped = {
+        ...meta,
+        source: meta.source ?? "virlow-mcp",
+        created: meta.created ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const row = await this.writeNote(key, null, label, text, stamped, folderId);
+      if (this.epoch === startEpoch) {
+        this.cache.set(row.id, {
+          id: row.id,
+          label,
+          text,
+          meta: stamped,
+          folderId,
+          ...namespaceField(tree.namespaceOf(folderId)),
+          embedding,
+          updatedAt: row.updatedAt
+        });
+        this.embeddings?.set(row.id, row.updatedAt, embedding);
+        await this.saveEmbeddings(key, startEpoch);
+      }
+      const similar = findSimilar(embedding, candidates).map(({ id, similarity }) => {
+        const memory = this.cache.get(id);
+        return {
+          id,
+          label: memory.label,
+          text: memory.text,
+          similarity: round3(similarity)
+        };
+      });
+      return { action: "stored", id: row.id, similar };
+    });
+  }
+  async search(query, namespace, limit = 10) {
+    await this.sync();
+    this.requireSession();
+    const embedding = await this.embedder.embed(query);
+    const ranked = rankBySimilarity(embedding, this.candidatesFor(namespace), limit);
+    return ranked.map(({ id, similarity }) => {
+      const memory = this.cache.get(id);
+      return {
+        id,
+        label: memory.label,
+        text: memory.text,
+        meta: memory.meta,
+        ...namespaceField(memory.namespace),
+        similarity: round3(similarity)
+      };
+    });
+  }
+  /** Requires a prior sync() in the same unlock to have populated the cache. */
+  list(namespace) {
+    this.requireSession();
+    return [...this.cache.values()].filter((m) => namespace === void 0 || m.namespace === namespace || m.namespace === void 0);
+  }
+  update(id, changes) {
+    return this.enqueue(async () => {
+      await this.sync();
+      const key = this.requireSession();
+      const startEpoch = this.epoch;
+      const existing = this.cache.get(id);
+      if (!existing)
+        throw new Error(`Memory ${id} not found`);
+      const label = changes.label ?? existing.label;
+      const text = changes.text ?? existing.text;
+      const meta = mergeMeta(existing.meta, changes.meta ?? {});
+      const row = await this.writeNote(key, id, label, text, meta);
+      const embedding = await this.embedder.embed(embeddingInput(label, text));
+      if (this.epoch !== startEpoch)
+        return;
+      this.cache.set(id, { ...existing, label, text, meta, embedding, updatedAt: row.updatedAt });
+      this.embeddings?.set(id, row.updatedAt, embedding);
+      await this.saveEmbeddings(key, startEpoch);
+    });
+  }
+  /** Trashes the note — recoverable from the app's Trash, never hard-deleted. */
+  delete(id) {
+    return this.enqueue(async () => {
+      const key = this.requireSession();
+      const startEpoch = this.epoch;
+      await this.api.updateNote(id, { deleted: true });
+      if (this.epoch !== startEpoch)
+        return;
+      this.cache.delete(id);
+      this.embeddings?.delete(id);
+      await this.saveEmbeddings(key, startEpoch);
+    });
+  }
+  /** Dedupe and search candidates: the named namespace plus the global root. */
+  candidatesFor(namespace) {
+    const result = [];
+    for (const memory of this.cache.values()) {
+      if (memory.namespace === namespace || memory.namespace === void 0) {
+        result.push({ id: memory.id, embedding: memory.embedding });
+      }
+    }
+    return result;
+  }
+  /** Create or update a memory note, encrypting through the note field
+   * helpers. `noteId === null` creates. */
+  async writeNote(key, noteId, label, text, meta, folderId) {
+    const body = toCodeEnvelope(serializeMemoryBody(text, meta));
+    const salt = bytesToBase64(crypto.getRandomValues(new Uint8Array(32)));
+    const { encryptedTitle, encryptedContent, iv } = await encryptNoteFields(key, label, body);
+    const write = {
+      title: "[ENCRYPTED]",
+      content: "[ENCRYPTED]",
+      encryptedTitle,
+      encryptedContent,
+      iv,
+      salt,
+      type: "code",
+      // Mirrored so the app can filter memories by tag. The frontmatter stays
+      // the source of truth; this column follows it on every write we make.
+      tags: meta.tags ?? []
+    };
+    if (folderId !== void 0)
+      write.folderId = folderId;
+    return noteId === null ? this.api.createNote(write) : this.api.updateNote(noteId, write);
+  }
+  async decryptRow(key, row) {
+    if (row.encryptedTitle && row.encryptedContent && row.iv) {
+      return decryptNoteFields(key, row.encryptedTitle, row.encryptedContent, row.iv);
+    }
+    return { title: row.title, content: row.content };
+  }
+  async requireTree() {
+    this.tree ??= await resolveMemoryTree(this.api);
+    return this.tree;
+  }
+  async requireEmbeddings(key) {
+    this.embeddings ??= this.cacheFactory(this.vault.session.userId);
+    if (!this.embeddingsLoaded) {
+      await this.embeddings.load(key);
+      this.embeddingsLoaded = true;
+    }
+    return this.embeddings;
+  }
+  /** Persisting after a lock would write vectors the user just cleared. */
+  async saveEmbeddings(key, startEpoch) {
+    if (this.epoch !== startEpoch)
+      return;
+    await this.embeddings?.save(key);
+  }
+  requireSession() {
+    const key = this.vault.session.key;
+    this.vault.touch();
+    return key;
+  }
+  /** Serializes add/update/delete so two overlapping mutation tool calls never
+   * interleave — two concurrent near-duplicate adds must run their
+   * dedupe-check-then-write critical section one at a time, or both would miss
+   * the other's pending write and both create. */
+  enqueue(fn) {
+    const next = this.mutationChain.then(fn, fn);
+    this.mutationChain = next.catch(() => {
+    });
+    return next;
+  }
+};
+function embeddingInput(label, fact) {
+  return `${label}
+${fact}`;
+}
+function namespaceField(namespace) {
+  return namespace === void 0 ? {} : { namespace };
+}
+
+// ../../packages/mcp-core/dist/embedding-cache.js
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import path from "node:path";
+var CACHE_VERSION = 1;
+var EmbeddingCache = class {
+  file;
+  embeddingModel;
+  dir;
+  records = /* @__PURE__ */ new Map();
+  dirty = false;
+  constructor(opts) {
+    this.dir = opts.dir;
+    this.embeddingModel = opts.embeddingModel;
+    const name = createHash("sha256").update(opts.userId).digest("hex");
+    this.file = path.join(opts.dir, `${name}.bin`);
+  }
+  async load(key) {
+    let parsed;
+    try {
+      const blob = await readFile(this.file, "utf8");
+      const bytes = await decryptBytesBlob(key, blob);
+      parsed = JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      return;
+    }
+    if (parsed.version !== CACHE_VERSION)
+      return;
+    if (parsed.embeddingModel !== this.embeddingModel)
+      return;
+    if (!parsed.records || typeof parsed.records !== "object")
+      return;
+    for (const [noteId, record] of Object.entries(parsed.records)) {
+      if (!record || typeof record.v !== "string" || typeof record.u !== "string") {
+        continue;
+      }
+      const bytes = base64ToBytes(record.v);
+      if (bytes.byteLength % 4 !== 0)
+        continue;
+      const vector = new Float32Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+      this.records.set(noteId, { vector, updatedAt: record.u });
+    }
+    this.dirty = false;
+  }
+  /** The cached vector, but only if the note has not been edited since. */
+  get(noteId, updatedAt) {
+    const record = this.records.get(noteId);
+    return record && record.updatedAt === updatedAt ? record.vector : void 0;
+  }
+  set(noteId, updatedAt, vector) {
+    this.records.set(noteId, { vector, updatedAt });
+    this.dirty = true;
+  }
+  delete(noteId) {
+    if (this.records.delete(noteId))
+      this.dirty = true;
+  }
+  clear() {
+    if (this.records.size > 0)
+      this.dirty = true;
+    this.records.clear();
+  }
+  async save(key) {
+    if (!this.dirty)
+      return;
+    const records = {};
+    for (const [noteId, { vector, updatedAt }] of this.records) {
+      const bytes = new Uint8Array(vector.buffer.slice(vector.byteOffset, vector.byteOffset + vector.byteLength));
+      records[noteId] = { v: bytesToBase64(bytes), u: updatedAt };
+    }
+    const payload = {
+      version: CACHE_VERSION,
+      embeddingModel: this.embeddingModel,
+      records
+    };
+    const blob = await encryptBytesBlob(key, new TextEncoder().encode(JSON.stringify(payload)));
+    await mkdir(this.dir, { recursive: true, mode: 448 });
+    const tmp = `${this.file}.${randomUUID()}.tmp`;
+    await writeFile(tmp, blob, { mode: 384 });
+    await rename(tmp, this.file);
+    this.dirty = false;
+  }
+  get size() {
+    return this.records.size;
+  }
+};
+
+// ../../packages/mcp-core/dist/memories-enabled.js
+async function memoriesAllowed(api) {
+  try {
+    const me = await api.me();
+    return me.memoriesEnabled === true;
+  } catch {
+    return false;
+  }
+}
+var MEMORIES_DISABLED_MESSAGE = 'AI memories are switched off for this account. Turn on "AI memories" in Settings \u2192 Security in the Virlow app to use this tool.';
+
+// src/server.ts
+import os from "node:os";
+import path2 from "node:path";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/unlock.ts
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import * as http from "node:http";
+var UNLOCK_TIMEOUT_MS = 5 * 60 * 1e3;
+var MAX_BAD_NONCE_ATTEMPTS = 3;
+async function performUnlock(api, vault, creds) {
+  const loginResult = await api.login(creds.email, creds.password);
+  let tokens;
+  if (loginResult.mfaRequired) {
+    if (!creds.totpCode) {
+      throw new Error("This account has 2FA enabled \u2014 enter the 6-digit code");
+    }
+    tokens = await api.verify2fa(loginResult.mfaToken, { code: creds.totpCode });
+  } else {
+    tokens = { accessToken: loginResult.accessToken, refreshToken: loginResult.refreshToken };
+  }
+  api.setTokens(tokens);
+  const me = await api.me();
+  const status = await api.encryptionStatus();
+  const { key, keyString } = await deriveMasterKey(creds.masterPassword, me.id);
+  if (status.verifier) {
+    const ok = await verifyVerifierBlob(key, status.verifier);
+    if (!ok) {
+      api.setTokens(null);
+      throw new Error("Master password is incorrect");
+    }
+  } else {
+    const { notes } = await api.listNotes({ limit: 1 });
+    const note = notes[0];
+    if (note?.encryptedTitle && note.iv) {
+      const ok = await canDecryptWithKey(key, note.encryptedTitle, note.iv);
+      if (!ok) {
+        api.setTokens(null);
+        throw new Error("Master password is incorrect");
+      }
+    }
+  }
+  const nonExtractableKey = await importMasterKey(keyString);
+  vault.setUnlocked({ key: nonExtractableKey, userId: me.id, email: me.email });
+  api.onTokensRotated = () => {
+    vault.touch();
+  };
+}
+function renderForm(nonce, error) {
+  const errorHtml = error ? `<p class="error">${escapeHtml(error)}</p>` : "";
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<title>Unlock Virlow</title>
+<style>
+  body { font-family: system-ui, sans-serif; max-width: 420px; margin: 48px auto; padding: 0 16px; color: #1a1a1a; }
+  h1 { font-size: 1.4rem; }
+  label { display: block; margin-top: 12px; font-weight: 600; }
+  input { width: 100%; padding: 8px; margin-top: 4px; box-sizing: border-box; font-size: 1rem; }
+  button { margin-top: 20px; padding: 10px 16px; font-size: 1rem; cursor: pointer; }
+  p.note { color: #555; font-size: 0.9rem; }
+  p.error { color: #b00020; font-weight: 600; }
+</style>
+</head>
+<body>
+<h1>Unlock Virlow</h1>
+<p class="note">
+  Credentials entered here are sent only to this local process and the
+  Virlow API. They are never seen by any AI model or logged.
+</p>
+${errorHtml}
+<form method="POST" action="/unlock?nonce=${encodeURIComponent(nonce)}" autocomplete="off">
+  <label for="email">Email</label>
+  <input type="email" id="email" name="email" autocomplete="off" required />
+
+  <label for="password">Password</label>
+  <input type="password" id="password" name="password" autocomplete="off" required />
+
+  <label for="masterPassword">Master password</label>
+  <input type="password" id="masterPassword" name="masterPassword" autocomplete="off" required />
+
+  <label for="totpCode">2FA code (only if 2FA is enabled on your account)</label>
+  <input type="text" id="totpCode" name="totpCode" autocomplete="off" inputmode="numeric" pattern="[0-9]*" />
+
+  <button type="submit">Unlock</button>
+</form>
+</body>
+</html>`;
+}
+function renderSuccess() {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<title>Unlock Virlow</title>
+<style>
+  body { font-family: system-ui, sans-serif; max-width: 420px; margin: 48px auto; padding: 0 16px; color: #1a1a1a; }
+</style>
+</head>
+<body>
+<h1>Virlow unlocked</h1>
+<p>You can close this tab and return to your MCP client.</p>
+</body>
+</html>`;
+}
+function escapeHtml(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk.toString("utf8");
+    });
+    req.on("end", () => resolve(data));
+    req.on("error", reject);
+  });
+}
+function openInBrowser(url) {
+  const platform = process.platform;
+  const [cmd, args] = platform === "win32" ? ["cmd", ["/c", "start", "", url]] : platform === "darwin" ? ["open", [url]] : ["xdg-open", [url]];
+  try {
+    const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+      process.stderr.write("virlow-mcp: could not open the unlock page in a browser automatically\n");
+    });
+    child.unref();
+  } catch {
+  }
+}
+function startUnlockServer(api, vault, opts = {}) {
+  const openBrowser = opts.openBrowser ?? true;
+  return new Promise((resolveStart, rejectStart) => {
+    const nonce = randomBytes(32).toString("hex");
+    let badNonceAttempts = 0;
+    let settled = false;
+    let timeoutHandle;
+    let resolveDone;
+    let rejectDone;
+    const done = new Promise((res, rej) => {
+      resolveDone = res;
+      rejectDone = rej;
+    });
+    done.catch(() => {
+    });
+    const finishSuccess = () => {
+      if (settled) return;
+      settled = true;
+      closeServer();
+      resolveDone();
+    };
+    const finishFailure = (err) => {
+      if (settled) return;
+      settled = true;
+      closeServer();
+      rejectDone(err);
+    };
+    const closeServer = () => {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      server.close();
+    };
+    const server = http.createServer((req, res) => {
+      handleRequest(req, res).catch(() => {
+        if (!res.headersSent) {
+          res.statusCode = 500;
+          res.setHeader("content-type", "text/plain");
+        }
+        res.end("Internal error");
+      });
+    });
+    async function handleRequest(req, res) {
+      const requestUrl = new URL(req.url ?? "/", "http://127.0.0.1");
+      if (requestUrl.pathname !== "/unlock") {
+        res.statusCode = 404;
+        res.setHeader("content-type", "text/plain");
+        res.end("Not found");
+        return;
+      }
+      const providedNonce = requestUrl.searchParams.get("nonce");
+      if (providedNonce !== nonce) {
+        badNonceAttempts += 1;
+        res.statusCode = 403;
+        res.setHeader("content-type", "text/plain");
+        res.end("Forbidden");
+        if (badNonceAttempts >= MAX_BAD_NONCE_ATTEMPTS) {
+          finishFailure(new Error("Unlock server closed after repeated invalid requests"));
+        }
+        return;
+      }
+      if (req.method === "GET") {
+        res.statusCode = 200;
+        res.setHeader("content-type", "text/html; charset=utf-8");
+        res.end(renderForm(nonce));
+        return;
+      }
+      if (req.method === "POST") {
+        const rawBody = await readBody(req);
+        const params = new URLSearchParams(rawBody);
+        const creds = {
+          email: params.get("email") ?? "",
+          password: params.get("password") ?? "",
+          masterPassword: params.get("masterPassword") ?? "",
+          totpCode: params.get("totpCode") || void 0
+        };
+        try {
+          await performUnlock(api, vault, creds);
+          res.statusCode = 200;
+          res.setHeader("content-type", "text/html; charset=utf-8");
+          res.end(renderSuccess());
+          finishSuccess();
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Unlock failed";
+          res.statusCode = 200;
+          res.setHeader("content-type", "text/html; charset=utf-8");
+          res.end(renderForm(nonce, message));
+        }
+        return;
+      }
+      res.statusCode = 404;
+      res.setHeader("content-type", "text/plain");
+      res.end("Not found");
+    }
+    server.on("error", (err) => {
+      rejectStart(err);
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        rejectStart(new Error("Failed to start unlock server"));
+        return;
+      }
+      const url = `http://127.0.0.1:${address.port}/unlock?nonce=${nonce}`;
+      timeoutHandle = setTimeout(() => {
+        finishFailure(new Error("Unlock timed out after 5 minutes"));
+      }, UNLOCK_TIMEOUT_MS);
+      timeoutHandle.unref?.();
+      if (openBrowser) {
+        openInBrowser(url);
+      }
+      resolveStart({ url, done });
+    });
+  });
+}
+
+// src/version.ts
+var VERSION = true ? "3.11.4" : "dev";
+
+// src/server.ts
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errorResult(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function mapError(err) {
+  if (err instanceof LockedError) return err.message;
+  if (err instanceof ApiError) return `API error ${err.status}: ${err.message}`;
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function wrap(fn) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (err) {
+      return errorResult(mapError(err));
+    }
+  };
+}
+function formatSyncStats(stats) {
+  return `synced ${stats.added} new, ${stats.updated} changed, removed ${stats.removed}`;
+}
+function formatMeta(meta) {
+  const parts = [];
+  if (meta.source) parts.push(meta.source);
+  if (meta.tags?.length) parts.push(meta.tags.join(", "));
+  if (meta.confidence) parts.push(`confidence ${meta.confidence}`);
+  return parts.length > 0 ? ` [${parts.join(" \xB7 ")}]` : "";
+}
+var truncate = (text, max = 120) => text.length > max ? `${text.slice(0, max)}\u2026` : text;
+function defaultEmbeddingCacheDir() {
+  return path2.join(os.homedir(), ".virlow-mcp", "cache");
+}
+function createServices(opts) {
+  const api = new VirlowApi(opts.apiUrl);
+  const vault = new Vault(opts.autoLockMs);
+  let embedderPromise = null;
+  const getRealEmbedder = () => {
+    embedderPromise ??= createEmbedder({ cacheDir: opts.modelCacheDir }).catch((err) => {
+      embedderPromise = null;
+      throw err;
+    });
+    return embedderPromise;
+  };
+  const lazyEmbedder = {
+    embed: (text) => getRealEmbedder().then((embedder) => embedder.embed(text))
+  };
+  const memoryStore = new MemoryStore(
+    api,
+    vault,
+    lazyEmbedder,
+    (userId) => new EmbeddingCache({
+      dir: opts.embeddingCacheDir ?? defaultEmbeddingCacheDir(),
+      userId,
+      embeddingModel: EMBEDDING_MODEL_TAG
+    })
+  );
+  const notesService = new NotesService(api, vault);
+  return { api, vault, memoryStore, notesService };
+}
+function buildServer(opts) {
+  const { api, vault, memoryStore, notesService } = opts.services ?? createServices(opts);
+  const server = new McpServer({ name: "virlow-mcp", version: VERSION });
+  server.registerTool(
+    "unlock",
+    {
+      description: "Open a local browser window where the USER signs in and enters their Virlow master password. This tool returns immediately once the browser is opened \u2014 it does NOT wait for the user to finish. Call the status tool afterward to confirm the vault unlocked. Never ask the user for their password or account credentials yourself, and never relay a password through this tool or any other \u2014 credentials are entered only in the browser form and never seen by any AI model."
+    },
+    wrap(async () => {
+      const { url } = await startUnlockServer(api, vault, { openBrowser: true });
+      return textResult(`Browser opened at ${url}. Complete the unlock form there, then run status to confirm.`);
+    })
+  );
+  server.registerTool(
+    "lock",
+    {
+      description: "Immediately lock the vault, discarding the in-memory decryption key and clearing all cached memories and notes. Use this when the user is done with a session or asks to lock explicitly. Safe to call even if already locked."
+    },
+    wrap(async () => {
+      vault.lock();
+      return textResult("Locked.");
+    })
+  );
+  server.registerTool(
+    "status",
+    {
+      description: "Report whether the vault is currently locked or unlocked, and which account it's unlocked as. Call this after unlock to confirm the user finished the browser form, and before any memory/notes tool if you are unsure of the current lock state."
+    },
+    wrap(async () => {
+      return textResult(JSON.stringify(vault.status()));
+    })
+  );
+  const requireMemories = async () => {
+    if (!vault.isUnlocked()) return;
+    if (!await memoriesAllowed(api)) {
+      throw new Error(MEMORIES_DISABLED_MESSAGE);
+    }
+  };
+  if (opts.memoriesEnabled !== false) {
+    server.registerTool(
+      "add_memory",
+      {
+        description: "Store a distilled fact about the user or project so any AI tool can recall it later. The label is a short title for the memory; the text is the fact itself. Use the namespace argument for project-specific facts (omit it for facts that apply everywhere). If a very similar memory already exists it is updated in place rather than duplicated. Memories are ordinary encrypted notes in the user's Memories folder \u2014 they can read and edit them, metadata included, in the Virlow app. Requires the vault to be unlocked. First use in this process downloads ~30MB of public embedding-model weights.",
+        inputSchema: {
+          label: z.string().min(1).max(80),
+          text: z.string().min(1).max(4e3),
+          namespace: z.string().max(100).optional(),
+          tags: z.array(z.string().max(50)).max(20).optional(),
+          confidence: z.string().max(20).optional(),
+          source: z.string().max(50).optional()
+        }
+      },
+      wrap(
+        async (args) => {
+          const meta = {};
+          if (args.tags !== void 0) meta.tags = args.tags;
+          if (args.confidence !== void 0) meta.confidence = args.confidence;
+          if (args.source !== void 0) meta.source = args.source;
+          await requireMemories();
+          const result = await memoryStore.add(args.label, args.text, args.namespace, meta);
+          const message = result.action === "updated" ? `updated existing memory ${result.id}` : `stored ${result.id}`;
+          if (result.similar.length === 0) return textResult(message);
+          const lines = result.similar.map(
+            (s) => `- [${s.id}] (${s.similarity}) ${s.label} \u2014 ${truncate(s.text)}`
+          );
+          return textResult(`${message}
+
+similar existing memories:
+${lines.join("\n")}`);
+        }
+      )
+    );
+    server.registerTool(
+      "search_memory",
+      {
+        description: "Search stored memories by semantic similarity to a query. Call this at the start of a task with the task topic to recall relevant facts before acting. Results are ranked by similarity; use namespace to scope to a project. Requires the vault to be unlocked. First use in this process downloads ~30MB of public embedding-model weights.",
+        inputSchema: {
+          query: z.string().min(1).max(500),
+          namespace: z.string().max(100).optional(),
+          limit: z.number().int().min(1).max(50).optional()
+        }
+      },
+      wrap(async (args) => {
+        await requireMemories();
+        const statsPromise = memoryStore.sync();
+        const resultsPromise = memoryStore.search(args.query, args.namespace, args.limit ?? 10);
+        const [stats, results] = await Promise.all([statsPromise, resultsPromise]);
+        const lines = results.map(
+          (r, i) => `${i + 1}. [${r.id}] (similarity ${r.similarity}) ${r.label} \u2014 ${r.text}${r.namespace ? ` (namespace: ${r.namespace})` : ""}${formatMeta(r.meta)}`
+        );
+        const body = lines.length > 0 ? lines.join("\n") : "(no matching memories found)";
+        return textResult(`${body}
+
+${formatSyncStats(stats)}`);
+      })
+    );
+    server.registerTool(
+      "list_memories",
+      {
+        description: "List cached memories, optionally filtered by namespace. Syncs with the server first so the list reflects the latest state across devices. Requires the vault to be unlocked.",
+        inputSchema: {
+          namespace: z.string().max(100).optional(),
+          limit: z.number().int().min(1).max(50).optional()
+        }
+      },
+      wrap(async (args) => {
+        await requireMemories();
+        const stats = await memoryStore.sync();
+        const items = memoryStore.list(args.namespace).slice(0, args.limit ?? 50);
+        const lines = items.map(
+          (m, i) => `${i + 1}. [${m.id}] ${m.label} \u2014 ${m.text}${m.namespace ? ` (namespace: ${m.namespace})` : ""}${formatMeta(m.meta)}`
+        );
+        const body = lines.length > 0 ? lines.join("\n") : "(no memories found)";
+        return textResult(`${body}
+
+${formatSyncStats(stats)}`);
+      })
+    );
+    server.registerTool(
+      "update_memory",
+      {
+        description: "Update an existing memory by id. Any field you omit is left alone, including metadata you do not name and the date the memory was first created. Requires the vault to be unlocked.",
+        inputSchema: {
+          id: z.string().min(1),
+          label: z.string().min(1).max(80).optional(),
+          text: z.string().min(1).max(4e3).optional(),
+          tags: z.array(z.string().max(50)).max(20).optional(),
+          confidence: z.string().max(20).optional()
+        }
+      },
+      wrap(
+        async (args) => {
+          if (args.label === void 0 && args.text === void 0 && args.tags === void 0 && args.confidence === void 0) {
+            throw new Error("update_memory needs at least one of label, text, tags, or confidence");
+          }
+          const meta = {};
+          if (args.tags !== void 0) meta.tags = args.tags;
+          if (args.confidence !== void 0) meta.confidence = args.confidence;
+          const changes = { meta };
+          if (args.label !== void 0) changes.label = args.label;
+          if (args.text !== void 0) changes.text = args.text;
+          await requireMemories();
+          await memoryStore.update(args.id, changes);
+          return textResult(`updated memory ${args.id}`);
+        }
+      )
+    );
+    server.registerTool(
+      "delete_memory",
+      {
+        description: "Move a memory to the Trash by id. It stops being recalled immediately, and the user can restore it from the Virlow app. Requires the vault to be unlocked.",
+        inputSchema: {
+          id: z.string().min(1)
+        }
+      },
+      wrap(async (args) => {
+        await requireMemories();
+        await memoryStore.delete(args.id);
+        return textResult(`trashed memory ${args.id}`);
+      })
+    );
+  }
+  server.registerTool(
+    "search_notes",
+    {
+      description: "Full-text search over note titles and content, returning matching notes with a short snippet. Requires the vault to be unlocked.",
+      inputSchema: {
+        query: z.string().min(1).max(500),
+        limit: z.number().int().min(1).max(50).optional()
+      }
+    },
+    wrap(async (args) => {
+      const { results, scanned, truncated } = await notesService.searchNotes(args.query, args.limit ?? 20);
+      const lines = results.map((r, i) => `${i + 1}. [${r.id}] ${r.title} \u2014 ${r.snippet}`);
+      const body = lines.length > 0 ? lines.join("\n") : "(no matching notes found)";
+      const scanNote = truncated ? `
+
+(scanned ${scanned} notes; more notes exist than were scanned \u2014 narrow your query for full coverage)` : "";
+      return textResult(`${body}${scanNote}`);
+    })
+  );
+  server.registerTool(
+    "list_notes",
+    {
+      description: "List notes with pagination, optionally filtered by folder or starred/archived state. Requires the vault to be unlocked.",
+      inputSchema: {
+        folderId: z.string().optional(),
+        starred: z.boolean().optional(),
+        archived: z.boolean().optional(),
+        page: z.number().int().min(1).optional(),
+        limit: z.number().int().min(1).max(50).optional()
+      }
+    },
+    wrap(
+      async (args) => {
+        const { notes, pagination, withheld, exposure } = await notesService.listNotes(args);
+        const lines = notes.map(
+          (n, i) => `${i + 1}. [${n.id}]${n.starred ? " *" : ""} ${n.title}`
+        );
+        const body = lines.length > 0 ? lines.join("\n") : "(no notes found)";
+        return textResult(
+          `${body}
+
+page ${pagination.page} of ${pagination.pages} (${pagination.total} total)` + filteredNotice(withheld, exposure)
+        );
+      }
+    )
+  );
+  server.registerTool(
+    "list_folders",
+    {
+      description: "List the note folders exposed to MCP. Folders the user has not switched on are not listed; the response says how many were withheld. Requires the vault to be unlocked."
+    },
+    wrap(async () => {
+      const { folders, withheld } = await notesService.listFolders();
+      const lines = folders.map((f, i) => `${i + 1}. [${f.id}] ${f.name}`);
+      const body = lines.length > 0 ? lines.join("\n") : "(no folders are exposed to MCP)";
+      const notice = withheld > 0 ? `
+
+(${withheld} folder${withheld === 1 ? "" : "s"} not shown: not exposed to MCP. Turn on "Expose to MCP" in a folder's settings in the Virlow app to include it.)` : "";
+      return textResult(body + notice);
+    })
+  );
+  server.registerTool(
+    "read_note",
+    {
+      description: "Read the full title and content of a note by id. Requires the vault to be unlocked.",
+      inputSchema: {
+        id: z.string().min(1)
+      }
+    },
+    wrap(async (args) => {
+      const note = await notesService.readNote(args.id);
+      return textResult(`# ${note.title}
+
+${note.content}`);
+    })
+  );
+  server.registerTool(
+    "create_note",
+    {
+      description: "Create a new note with a title and content, optionally placed in a folder. Requires the vault to be unlocked.",
+      inputSchema: {
+        title: z.string().min(1).max(200),
+        content: z.string().max(5e4).optional(),
+        folderId: z.string().optional(),
+        type: z.string().max(50).optional()
+      }
+    },
+    wrap(async (args) => {
+      const note = await notesService.createNote(args.title, args.content ?? "", args.folderId, args.type);
+      return textResult(`created note ${note.id}`);
+    })
+  );
+  server.registerTool(
+    "update_note",
+    {
+      description: "Update the title and/or content of an existing note by id. Only the provided fields are changed. Requires the vault to be unlocked.",
+      inputSchema: {
+        id: z.string().min(1),
+        title: z.string().min(1).max(200).optional(),
+        content: z.string().max(5e4).optional()
+      }
+    },
+    wrap(async (args) => {
+      await notesService.updateNote(args.id, { title: args.title, content: args.content });
+      return textResult(`updated note ${args.id}`);
+    })
+  );
+  server.registerTool(
+    "move_note",
+    {
+      description: "Move a note into a different folder, or to no folder by passing folderId: null. Requires the vault to be unlocked.",
+      inputSchema: {
+        id: z.string().min(1),
+        folderId: z.string().nullable()
+      }
+    },
+    wrap(async (args) => {
+      await notesService.moveNote(args.id, args.folderId);
+      return textResult(`moved note ${args.id}`);
+    })
+  );
+  server.registerTool(
+    "set_star",
+    {
+      description: "Star or unstar a note by id. Requires the vault to be unlocked.",
+      inputSchema: {
+        id: z.string().min(1),
+        starred: z.boolean()
+      }
+    },
+    wrap(async (args) => {
+      await notesService.setStar(args.id, args.starred);
+      return textResult(args.starred ? `starred note ${args.id}` : `unstarred note ${args.id}`);
+    })
+  );
+  server.registerTool(
+    "archive_note",
+    {
+      description: "Archive or unarchive a note by id. Requires the vault to be unlocked.",
+      inputSchema: {
+        id: z.string().min(1),
+        archived: z.boolean()
+      }
+    },
+    wrap(async (args) => {
+      await notesService.archiveNote(args.id, args.archived);
+      return textResult(args.archived ? `archived note ${args.id}` : `unarchived note ${args.id}`);
+    })
+  );
+  server.registerTool(
+    "trash_note",
+    {
+      description: "Move a note to the trash by id. Requires the vault to be unlocked.",
+      inputSchema: {
+        id: z.string().min(1)
+      }
+    },
+    wrap(async (args) => {
+      await notesService.trashNote(args.id);
+      return textResult(`trashed note ${args.id}`);
+    })
+  );
+  server.registerTool(
+    "create_folder",
+    {
+      description: "Create a new note folder, optionally nested under a parent folder. Requires the vault to be unlocked.",
+      inputSchema: {
+        name: z.string().min(1).max(100),
+        parentId: z.string().nullable().optional()
+      }
+    },
+    wrap(async (args) => {
+      const folder = await notesService.createFolder(args.name, args.parentId);
+      return textResult(`created folder ${folder.id}`);
+    })
+  );
+  return { server, vault };
+}
+
+// src/http.ts
+import { createServer as createServer2 } from "node:http";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
+import path3 from "node:path";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+function defaultTokenPath(homeDir) {
+  return path3.join(homeDir, ".virlow-mcp", "http-token");
+}
+async function loadOrCreateToken(tokenPath) {
+  try {
+    const existing = (await readFile2(tokenPath, "utf8")).trim();
+    if (existing.length > 0) return existing;
+  } catch {
+  }
+  const token = randomBytes2(32).toString("base64url");
+  await mkdir2(path3.dirname(tokenPath), { recursive: true, mode: 448 });
+  await writeFile2(tokenPath, `${token}
+`, { mode: 384 });
+  return token;
+}
+function tokenMatches(provided, expected) {
+  const a = Buffer.from(provided);
+  const b = Buffer.from(expected);
+  if (a.length !== b.length) {
+    timingSafeEqual(b, b);
+    return false;
+  }
+  return timingSafeEqual(a, b);
+}
+function bearerFrom(header) {
+  if (!header) return null;
+  const match = /^Bearer[ ]+(.+)$/i.exec(header.trim());
+  return match ? match[1].trim() : null;
+}
+async function handleWithFreshTransport(server, req, res) {
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: void 0
+  });
+  res.on("close", () => {
+    void transport.close();
+    void server.close();
+  });
+  await server.connect(transport);
+  await transport.handleRequest(req, res);
+}
+async function startHttpServer(opts) {
+  const host = opts.host ?? "127.0.0.1";
+  const mcpPath = opts.path ?? "/mcp";
+  const httpServer = createServer2((req, res) => {
+    const url = new URL(req.url ?? "/", `http://${host}`);
+    if (url.pathname === "/health") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ ok: true }));
+      return;
+    }
+    if (url.pathname !== mcpPath) {
+      res.writeHead(404).end();
+      return;
+    }
+    const provided = bearerFrom(req.headers.authorization);
+    if (provided === null || !tokenMatches(provided, opts.token)) {
+      res.writeHead(401, {
+        "content-type": "application/json",
+        "www-authenticate": "Bearer"
+      });
+      res.end(JSON.stringify({ error: "unauthorized" }));
+      return;
+    }
+    void handleWithFreshTransport(opts.makeServer(), req, res);
+  });
+  await new Promise((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(opts.port ?? 0, host, () => {
+      httpServer.removeListener("error", reject);
+      resolve();
+    });
+  });
+  const address = httpServer.address();
+  const port = typeof address === "object" && address !== null ? address.port : 0;
+  return {
+    port,
+    host,
+    close: () => new Promise((resolve) => {
+      httpServer.close(() => resolve());
+    })
+  };
+}
+
+// src/cli.ts
+function flagValue(name) {
+  const prefix = `--${name}=`;
+  const inline = process.argv.find((a) => a.startsWith(prefix));
+  if (inline) return inline.slice(prefix.length);
+  const idx = process.argv.indexOf(`--${name}`);
+  return idx !== -1 ? process.argv[idx + 1] : void 0;
+}
+async function main() {
+  if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    process.stdout.write(`${VERSION}
+`);
+    return;
+  }
+  const apiUrl = process.env.VIRLOW_API_URL ?? "https://api.virlow.com";
+  const modelCacheDir = path4.join(os2.homedir(), ".virlow-mcp", "models");
+  const embeddingCacheDir = path4.join(os2.homedir(), ".virlow-mcp", "cache");
+  const memoriesEnabled = !process.argv.includes("--no-memories");
+  const serverOpts = { apiUrl, modelCacheDir, embeddingCacheDir, memoriesEnabled };
+  const services = createServices(serverOpts);
+  const { server } = buildServer({ ...serverOpts, services });
+  if (process.argv.includes("--http")) {
+    const token = await loadOrCreateToken(
+      flagValue("token-file") ?? defaultTokenPath(os2.homedir())
+    );
+    const portFlag = flagValue("port");
+    const host = flagValue("host") ?? "127.0.0.1";
+    const running = await startHttpServer({
+      makeServer: () => buildServer({ ...serverOpts, services }).server,
+      token,
+      host,
+      ...portFlag !== void 0 ? { port: Number(portFlag) } : {}
+    });
+    process.stderr.write(
+      `virlow-mcp: listening on http://${running.host}:${running.port}/mcp
+`
+    );
+    if (host !== "127.0.0.1") {
+      process.stderr.write(
+        "virlow-mcp: WARNING \u2014 bound to a non-loopback address. Anyone who can reach this port and holds the token can read your decrypted notes.\n"
+      );
+    }
+    process.stderr.write(
+      `virlow-mcp: bearer token in ${flagValue("token-file") ?? defaultTokenPath(os2.homedir())}
+`
+    );
+    return;
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`virlow-mcp: fatal error: ${message}
+`);
+  process.exitCode = 1;
+});