@batalabs/virlow-mcp-core 3.11.4 → 3.11.6

package/dist/cjs/api.d.ts

@@ -0,0 +1,117 @@
+export declare class ApiError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export interface AuthTokens {
+    accessToken: string;
+    refreshToken: string;
+}
+export type LoginResult = {
+    mfaRequired: true;
+    mfaToken: string;
+} | {
+    mfaRequired?: false;
+    user: {
+        id: string;
+        email: string;
+    };
+    accessToken: string;
+    refreshToken: string;
+};
+export interface ApiNote {
+    id: string;
+    folderId: string | null;
+    type: string;
+    /** Plaintext columns: the real content for legacy (unencrypted) notes,
+     * or the literal "[ENCRYPTED]" placeholder once a note carries ciphertext. */
+    title: string;
+    content: string;
+    encryptedTitle: string | null;
+    encryptedContent: string | null;
+    iv: string | null;
+    salt: string | null;
+    starred: boolean | null;
+    archived: boolean | null;
+    deleted: boolean | null;
+    /** The web app segregates hidden notes client-side; virlow-mcp filters
+     * them out of listNotes/searchNotes for the same reason (see notes.ts). */
+    hidden: boolean | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface NoteWrite {
+    title: string;
+    content: string;
+    encryptedTitle: string;
+    encryptedContent: string;
+    iv: string;
+    salt: string;
+    folderId?: string | null;
+    type?: string;
+    tags?: string[];
+    starred?: boolean;
+    archived?: boolean;
+    deleted?: boolean;
+}
+export interface ApiFolder {
+    id: string;
+    name: string;
+    parentId: string | null;
+    /** Marks the single root folder whose notes are AI memories; null for every
+     * ordinary folder, including the namespace subfolders under that root. */
+    kind: 'memories' | null;
+    /** The user's "Expose to MCP" switch. False by default — nothing in this
+     * folder is shown to AI tools until they turn it on. */
+    mcpEnabled: boolean;
+}
+export declare class VirlowApi {
+    private readonly baseUrl;
+    private tokens;
+    private refreshInFlight;
+    onTokensRotated?: (tokens: AuthTokens) => void;
+    constructor(baseUrl: string);
+    setTokens(tokens: AuthTokens | null): void;
+    private request;
+    private refresh;
+    private doRefresh;
+    login(email: string, password: string): Promise<LoginResult>;
+    verify2fa(mfaToken: string, codeOrRecovery: {
+        code?: string;
+        recoveryCode?: string;
+    }): Promise<AuthTokens>;
+    me(): Promise<{
+        id: string;
+        email: string;
+        memoriesEnabled?: boolean;
+    }>;
+    encryptionStatus(): Promise<{
+        verifier: {
+            ciphertext: string;
+            iv: string;
+            salt: string;
+        } | null;
+    }>;
+    listNotes(params: {
+        page?: number;
+        limit?: number;
+        folderId?: string;
+        starred?: boolean;
+        archived?: boolean;
+        deleted?: boolean;
+    }): Promise<{
+        notes: ApiNote[];
+        pagination: {
+            page: number;
+            limit: number;
+            total: number;
+            pages: number;
+        };
+    }>;
+    getNote(id: string): Promise<ApiNote>;
+    createNote(body: NoteWrite): Promise<ApiNote>;
+    updateNote(id: string, body: Partial<NoteWrite>): Promise<ApiNote>;
+    listFolders(): Promise<{
+        folders: ApiFolder[];
+    }>;
+    createFolder(name: string, parentId?: string | null, kind?: 'memories'): Promise<ApiFolder>;
+}

package/dist/cjs/api.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirlowApi = exports.ApiError = void 0;
+class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'ApiError';
+    }
+}
+exports.ApiError = ApiError;
+class VirlowApi {
+    baseUrl;
+    tokens = null;
+    refreshInFlight = null;
+    onTokensRotated;
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    setTokens(tokens) {
+        this.tokens = tokens;
+    }
+    async request(method, path, 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}${path}`, {
+            method,
+            headers,
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        });
+        if (res.status === 401 && auth && retryOn401 && this.tokens) {
+            await this.refresh();
+            return this.request(method, path, body, { auth, retryOn401: false });
+        }
+        if (res.status === 204)
+            return undefined;
+        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 !== undefined)
+            query.set('page', String(params.page));
+        if (params.limit !== undefined)
+            query.set('limit', String(params.limit));
+        if (params.folderId !== undefined)
+            query.set('folderId', params.folderId);
+        if (params.starred !== undefined)
+            query.set('starred', String(params.starred));
+        if (params.archived !== undefined)
+            query.set('archived', String(params.archived));
+        if (params.deleted !== undefined)
+            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) {
+        // `kind` is omitted rather than sent as null: the API rejects unknown kinds
+        // and a namespace subfolder is an ordinary folder.
+        const body = {
+            name,
+            parentId,
+        };
+        if (kind !== undefined)
+            body.kind = kind;
+        return this.request('POST', '/api/folders', body);
+    }
+}
+exports.VirlowApi = VirlowApi;

package/dist/cjs/embedding-cache.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Embedding vectors cached on disk, encrypted under the master key.
+ *
+ * Embedding a few hundred memories takes long enough to be felt at the start
+ * of every session, so the vectors are kept between runs. They are derived
+ * from plaintext memories, so the file is AES-GCM ciphertext and nothing —
+ * not the note ids, not the timestamps — is readable without the key.
+ *
+ * Every failure mode is a silent miss: a missing file, a file written under a
+ * different master password, a different embedding model, or corrupt bytes all
+ * yield an empty cache that gets rebuilt. The cache is an optimisation, never
+ * a source of truth.
+ */
+export declare class EmbeddingCache {
+    private readonly file;
+    private readonly embeddingModel;
+    private readonly dir;
+    private records;
+    private dirty;
+    constructor(opts: {
+        dir: string;
+        userId: string;
+        embeddingModel: string;
+    });
+    load(key: CryptoKey): Promise<void>;
+    /** The cached vector, but only if the note has not been edited since. */
+    get(noteId: string, updatedAt: string): Float32Array | undefined;
+    set(noteId: string, updatedAt: string, vector: Float32Array): void;
+    delete(noteId: string): void;
+    clear(): void;
+    save(key: CryptoKey): Promise<void>;
+    get size(): number;
+}

package/dist/cjs/embedding-cache.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingCache = void 0;
+const promises_1 = require("node:fs/promises");
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+const virlow_crypto_1 = require("@batalabs/virlow-crypto");
+/** Bumped if the on-disk record shape ever changes; a mismatch is a cache miss. */
+const CACHE_VERSION = 1;
+/**
+ * Embedding vectors cached on disk, encrypted under the master key.
+ *
+ * Embedding a few hundred memories takes long enough to be felt at the start
+ * of every session, so the vectors are kept between runs. They are derived
+ * from plaintext memories, so the file is AES-GCM ciphertext and nothing —
+ * not the note ids, not the timestamps — is readable without the key.
+ *
+ * Every failure mode is a silent miss: a missing file, a file written under a
+ * different master password, a different embedding model, or corrupt bytes all
+ * yield an empty cache that gets rebuilt. The cache is an optimisation, never
+ * a source of truth.
+ */
+class EmbeddingCache {
+    file;
+    embeddingModel;
+    dir;
+    records = new Map();
+    dirty = false;
+    constructor(opts) {
+        this.dir = opts.dir;
+        this.embeddingModel = opts.embeddingModel;
+        // The user id is hashed so the filename itself identifies nobody.
+        const name = (0, node_crypto_1.createHash)('sha256').update(opts.userId).digest('hex');
+        this.file = node_path_1.default.join(opts.dir, `${name}.bin`);
+    }
+    async load(key) {
+        let parsed;
+        try {
+            const blob = await (0, promises_1.readFile)(this.file, 'utf8');
+            const bytes = await (0, virlow_crypto_1.decryptBytesBlob)(key, blob);
+            parsed = JSON.parse(new TextDecoder().decode(bytes));
+        }
+        catch {
+            // Missing, undecryptable, or malformed — all just a cold cache.
+            return;
+        }
+        if (parsed.version !== CACHE_VERSION)
+            return;
+        // Vectors from another model are meaningless against current ones: mixing
+        // them would produce similarity scores that silently misrank.
+        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 = (0, virlow_crypto_1.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 : undefined;
+    }
+    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: (0, virlow_crypto_1.bytesToBase64)(bytes), u: updatedAt };
+        }
+        const payload = {
+            version: CACHE_VERSION,
+            embeddingModel: this.embeddingModel,
+            records,
+        };
+        const blob = await (0, virlow_crypto_1.encryptBytesBlob)(key, new TextEncoder().encode(JSON.stringify(payload)));
+        await (0, promises_1.mkdir)(this.dir, { recursive: true, mode: 0o700 });
+        // Write-then-rename so an interrupted save cannot leave a half-written file
+        // where the next load expects ciphertext.
+        const tmp = `${this.file}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+        await (0, promises_1.writeFile)(tmp, blob, { mode: 0o600 });
+        await (0, promises_1.rename)(tmp, this.file);
+        this.dirty = false;
+    }
+    get size() {
+        return this.records.size;
+    }
+}
+exports.EmbeddingCache = EmbeddingCache;

package/dist/cjs/exposure.d.ts

@@ -0,0 +1,41 @@
+import type { ApiFolder } from './api.js';
+/**
+ * Which folders the user has actually opened to AI tools.
+ *
+ * Every folder carries an "Expose to MCP" switch — *"Let the local AI
+ * assistant read & edit this folder and its subfolders. Off by default."* —
+ * and until now nothing read it, so the app was telling users something untrue
+ * about who could see their notes. This is the thing that makes it true.
+ *
+ * The rule follows the switch's own wording: a folder is exposed when it, or
+ * any ancestor, is switched on. Turning a parent on therefore opens everything
+ * beneath it, and a child cannot opt back out — matching what the label
+ * promises rather than inventing a precedence rule the UI never mentions.
+ */
+export interface Exposure {
+    /** Whether notes in this folder may be shown. */
+    allows(folderId: string | null): boolean;
+    /** Folders the user has not opened, for reporting how much is hidden. */
+    hiddenFolderCount: number;
+    /** True when nothing at all is exposed — worth saying differently, since
+     * "no results" and "you have not opened anything yet" look identical
+     * otherwise. */
+    allHidden: boolean;
+}
+export interface ExposureOptions {
+    /** The memories root, if one exists. It and its namespace subfolders are
+     * exempt: the MCP server creates that tree and it exists solely for AI
+     * tools, so requiring the user to opt it in would be asking them to
+     * authorise a folder they never made for a purpose it already has. */
+    memoriesRootId?: string | null;
+}
+export declare function computeExposure(folders: ReadonlyArray<ApiFolder>, opts?: ExposureOptions): Exposure;
+/**
+ * The sentence appended to any result that was filtered. Never omitted when
+ * something was withheld: a quietly shortened list is indistinguishable from
+ * an empty vault, and the user would have no reason to suspect a setting.
+ */
+export declare function filteredNotice(hidden: {
+    inClosedFolders: number;
+    unfiled: number;
+}, exposure: Exposure): string;

package/dist/cjs/exposure.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeExposure = computeExposure;
+exports.filteredNotice = filteredNotice;
+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 = new Map();
+    const isExposed = (folderId) => {
+        const cached = resolved.get(folderId);
+        if (cached !== undefined)
+            return cached;
+        // Walk to the root, stopping at the first switched-on ancestor. The seen
+        // set keeps a corrupt parent cycle from hanging the server rather than
+        // trusting the data to be a tree.
+        const chain = [];
+        const seen = new Set();
+        let current = folderId;
+        let exposed = false;
+        while (current !== null && !seen.has(current)) {
+            seen.add(current);
+            const folder = byId.get(current);
+            if (folder === undefined)
+                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,
+    };
+}
+/**
+ * The sentence appended to any result that was filtered. Never omitted when
+ * something was withheld: a quietly shortened list is indistinguishable from
+ * an empty vault, and the user would have no reason to suspect a setting.
+ */
+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.');
+    }
+    // Worth saying separately: the remedy is different. There is no switch on a
+    // note that lives in no folder, so "turn on the folder" is useless advice —
+    // it has to be filed into an exposed folder first.
+    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 ? '' : `\n\n(${parts.join(' ')})`;
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,15 @@
+export { ApiError, VirlowApi } from './api.js';
+export type { ApiFolder, ApiNote, AuthTokens, LoginResult, NoteWrite } from './api.js';
+export { LockedError, Vault } from './vault.js';
+export type { UnlockedSession } from './vault.js';
+export { NotesService, SEARCH_SCAN_CAP } from './notes.js';
+export { MemoryStore, SYNC_PAGE_LIMIT } from './memories.js';
+export type { CachedMemory, SimilarMemory, SyncResult } from './memories.js';
+export { mergeMeta, parseMemoryNote, serializeMemoryBody, toCodeEnvelope, } from './memory-note.js';
+export type { MemoryMeta, ParsedMemoryNote } from './memory-note.js';
+export { MEMORIES_ROOT_NAME, ensureNamespace, resolveMemoryTree, } from './memory-tree.js';
+export type { MemoryTree } from './memory-tree.js';
+export { computeExposure, filteredNotice } from './exposure.js';
+export type { Exposure } from './exposure.js';
+export { EmbeddingCache } from './embedding-cache.js';
+export { MEMORIES_DISABLED_MESSAGE, memoriesAllowed } from './memories-enabled.js';

package/dist/cjs/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoriesAllowed = exports.MEMORIES_DISABLED_MESSAGE = exports.EmbeddingCache = exports.filteredNotice = exports.computeExposure = exports.resolveMemoryTree = exports.ensureNamespace = exports.MEMORIES_ROOT_NAME = exports.toCodeEnvelope = exports.serializeMemoryBody = exports.parseMemoryNote = exports.mergeMeta = exports.SYNC_PAGE_LIMIT = exports.MemoryStore = exports.SEARCH_SCAN_CAP = exports.NotesService = exports.Vault = exports.LockedError = exports.VirlowApi = exports.ApiError = void 0;
+var api_js_1 = require("./api.js");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return api_js_1.ApiError; } });
+Object.defineProperty(exports, "VirlowApi", { enumerable: true, get: function () { return api_js_1.VirlowApi; } });
+var vault_js_1 = require("./vault.js");
+Object.defineProperty(exports, "LockedError", { enumerable: true, get: function () { return vault_js_1.LockedError; } });
+Object.defineProperty(exports, "Vault", { enumerable: true, get: function () { return vault_js_1.Vault; } });
+var notes_js_1 = require("./notes.js");
+Object.defineProperty(exports, "NotesService", { enumerable: true, get: function () { return notes_js_1.NotesService; } });
+Object.defineProperty(exports, "SEARCH_SCAN_CAP", { enumerable: true, get: function () { return notes_js_1.SEARCH_SCAN_CAP; } });
+var memories_js_1 = require("./memories.js");
+Object.defineProperty(exports, "MemoryStore", { enumerable: true, get: function () { return memories_js_1.MemoryStore; } });
+Object.defineProperty(exports, "SYNC_PAGE_LIMIT", { enumerable: true, get: function () { return memories_js_1.SYNC_PAGE_LIMIT; } });
+var memory_note_js_1 = require("./memory-note.js");
+Object.defineProperty(exports, "mergeMeta", { enumerable: true, get: function () { return memory_note_js_1.mergeMeta; } });
+Object.defineProperty(exports, "parseMemoryNote", { enumerable: true, get: function () { return memory_note_js_1.parseMemoryNote; } });
+Object.defineProperty(exports, "serializeMemoryBody", { enumerable: true, get: function () { return memory_note_js_1.serializeMemoryBody; } });
+Object.defineProperty(exports, "toCodeEnvelope", { enumerable: true, get: function () { return memory_note_js_1.toCodeEnvelope; } });
+var memory_tree_js_1 = require("./memory-tree.js");
+Object.defineProperty(exports, "MEMORIES_ROOT_NAME", { enumerable: true, get: function () { return memory_tree_js_1.MEMORIES_ROOT_NAME; } });
+Object.defineProperty(exports, "ensureNamespace", { enumerable: true, get: function () { return memory_tree_js_1.ensureNamespace; } });
+Object.defineProperty(exports, "resolveMemoryTree", { enumerable: true, get: function () { return memory_tree_js_1.resolveMemoryTree; } });
+var exposure_js_1 = require("./exposure.js");
+Object.defineProperty(exports, "computeExposure", { enumerable: true, get: function () { return exposure_js_1.computeExposure; } });
+Object.defineProperty(exports, "filteredNotice", { enumerable: true, get: function () { return exposure_js_1.filteredNotice; } });
+var embedding_cache_js_1 = require("./embedding-cache.js");
+Object.defineProperty(exports, "EmbeddingCache", { enumerable: true, get: function () { return embedding_cache_js_1.EmbeddingCache; } });
+var memories_enabled_js_1 = require("./memories-enabled.js");
+Object.defineProperty(exports, "MEMORIES_DISABLED_MESSAGE", { enumerable: true, get: function () { return memories_enabled_js_1.MEMORIES_DISABLED_MESSAGE; } });
+Object.defineProperty(exports, "memoriesAllowed", { enumerable: true, get: function () { return memories_enabled_js_1.memoriesAllowed; } });

package/dist/cjs/memories-enabled.d.ts

@@ -0,0 +1,15 @@
+import type { VirlowApi } from './api.js';
+/**
+ * Whether the user has switched AI memories on, read fresh from the account.
+ *
+ * Deliberately not cached for the session. Turning the switch *on* being slow
+ * is an inconvenience; turning it *off* being slow is a privacy control that
+ * does not work. A user who switches memories off in the app expects the next
+ * tool call to respect it, not the next time they happen to restart their
+ * editor — and they would have no way to discover the difference.
+ *
+ * The cost is one GET alongside operations that already list folders, page
+ * through notes, decrypt, and embed.
+ */
+export declare function memoriesAllowed(api: VirlowApi): Promise<boolean>;
+export declare const MEMORIES_DISABLED_MESSAGE: string;

package/dist/cjs/memories-enabled.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEMORIES_DISABLED_MESSAGE = void 0;
+exports.memoriesAllowed = memoriesAllowed;
+/**
+ * Whether the user has switched AI memories on, read fresh from the account.
+ *
+ * Deliberately not cached for the session. Turning the switch *on* being slow
+ * is an inconvenience; turning it *off* being slow is a privacy control that
+ * does not work. A user who switches memories off in the app expects the next
+ * tool call to respect it, not the next time they happen to restart their
+ * editor — and they would have no way to discover the difference.
+ *
+ * The cost is one GET alongside operations that already list folders, page
+ * through notes, decrypt, and embed.
+ */
+async function memoriesAllowed(api) {
+    try {
+        const me = await api.me();
+        // An API that predates the column omits the field. Treat an unknown answer
+        // as "not enabled": this decides whether an AI may record facts about the
+        // user, and guessing yes is the expensive direction to be wrong in.
+        return me.memoriesEnabled === true;
+    }
+    catch {
+        // Fail closed. A network blip briefly disabling memories is a far better
+        // failure than a revoked setting continuing to work.
+        return false;
+    }
+}
+exports.MEMORIES_DISABLED_MESSAGE = 'AI memories are switched off for this account. Turn on "AI memories" in ' +
+    'Settings → Security in the Virlow app to use this tool.';