@batalabs/virlow-mcp-core 3.18.0 → 3.68.0

package/dist/cjs/api.d.ts

@@ -6,6 +6,14 @@ export interface AuthTokens {
     accessToken: string;
     refreshToken: string;
 }
+/** What `/api/auth/refresh` answers, minus the refresh token this client keeps. */
+export interface RefreshBody {
+    user: {
+        id: string;
+        email: string;
+    };
+    accessToken: string;
+}
 export type LoginResult = {
     mfaRequired: true;
     mfaToken: string;
@@ -38,6 +46,8 @@ export interface ApiNote {
     hidden: boolean | null;
     createdAt: string;
     updatedAt: string;
+    /** Encrypted v2 blob of the note's structured attrs (props, links, mentions). */
+    encryptedAttrs: string | null;
 }
 export interface NoteWrite {
     title: string;
@@ -52,6 +62,7 @@ export interface NoteWrite {
     starred?: boolean;
     archived?: boolean;
     deleted?: boolean;
+    encryptedAttrs?: string | null;
 }
 export interface ApiFolder {
     id: string;
@@ -63,14 +74,26 @@ export interface ApiFolder {
     /** 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;
+    /** Encrypted v2 blob of the folder's property and view definitions. */
+    encryptedSchema: string | null;
 }
 export declare class VirlowApi {
     private readonly baseUrl;
     private tokens;
     private refreshInFlight;
     onTokensRotated?: (tokens: AuthTokens) => void;
+    /** Fired when a refresh is refused outright and the session is gone. */
+    onTokensCleared?: () => void;
     constructor(baseUrl: string);
     setTokens(tokens: AuthTokens | null): void;
+    getTokens(): AuthTokens | null;
+    /**
+     * Rotate the refresh token exactly once no matter how many callers arrive
+     * while a rotation is pending. The API revokes the whole token family when a
+     * replaced refresh token is presented again, so two concurrent refreshes are
+     * not a race, they are a forced sign-out.
+     */
+    refreshSession(): Promise<RefreshBody>;
     private request;
     private refresh;
     private doRefresh;
@@ -135,4 +158,13 @@ export declare class VirlowApi {
         folders: ApiFolder[];
     }>;
     createFolder(name: string, parentId?: string | null, kind?: 'memories'): Promise<ApiFolder>;
+    /** Partial update of a folder. Only `encryptedSchema` is used from here so
+     * far, and it is forwarded as an already-encrypted blob: nothing in this
+     * client encrypts, and nothing on the server can read it. */
+    updateFolder(id: string, body: {
+        name?: string;
+        parentId?: string | null;
+        mcpEnabled?: boolean;
+        encryptedSchema?: string | null;
+    }): Promise<ApiFolder>;
 }

package/dist/cjs/api.js

@@ -60,12 +60,29 @@ class VirlowApi {
     tokens = null;
     refreshInFlight = null;
     onTokensRotated;
+    /** Fired when a refresh is refused outright and the session is gone. */
+    onTokensCleared;
     constructor(baseUrl) {
         this.baseUrl = baseUrl;
     }
     setTokens(tokens) {
         this.tokens = tokens;
     }
+    getTokens() {
+        return this.tokens;
+    }
+    /**
+     * Rotate the refresh token exactly once no matter how many callers arrive
+     * while a rotation is pending. The API revokes the whole token family when a
+     * replaced refresh token is presented again, so two concurrent refreshes are
+     * not a race, they are a forced sign-out.
+     */
+    refreshSession() {
+        this.refreshInFlight ??= this.doRefresh().finally(() => {
+            this.refreshInFlight = null;
+        });
+        return this.refreshInFlight;
+    }
     async request(method, path, body, opts = {}) {
         const { auth = true, retryOn401 = true } = opts;
         const headers = { 'content-type': 'application/json' };
@@ -89,17 +106,27 @@ class VirlowApi {
         return data;
     }
     refresh() {
-        this.refreshInFlight ??= this.doRefresh().finally(() => {
-            this.refreshInFlight = null;
-        });
-        return this.refreshInFlight;
+        return this.refreshSession().then(() => undefined);
     }
     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 });
+        let rotated;
+        try {
+            rotated = await this.request('POST', '/api/auth/refresh', { refreshToken: this.tokens.refreshToken }, { auth: false, retryOn401: false });
+        }
+        catch (err) {
+            // Only a definitive refusal ends the session. A network failure or a 5xx
+            // while the API restarts must leave the tokens in place for a retry.
+            if (err instanceof ApiError && err.status === 401) {
+                this.tokens = null;
+                this.onTokensCleared?.();
+            }
+            throw err;
+        }
         this.tokens = { accessToken: rotated.accessToken, refreshToken: rotated.refreshToken };
         this.onTokensRotated?.(this.tokens);
+        return { user: rotated.user, accessToken: rotated.accessToken };
     }
     login(email, password) {
         return this.request('POST', '/api/auth/login', { email, password }, { auth: false });
@@ -189,5 +216,11 @@ class VirlowApi {
             body.kind = kind;
         return this.request('POST', '/api/folders', body);
     }
+    /** Partial update of a folder. Only `encryptedSchema` is used from here so
+     * far, and it is forwarded as an already-encrypted blob: nothing in this
+     * client encrypts, and nothing on the server can read it. */
+    updateFolder(id, body) {
+        return this.request('PUT', `/api/folders/${id}`, body);
+    }
 }
 exports.VirlowApi = VirlowApi;

package/dist/cjs/attrs-extract.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Node-side twins of the web's src/lib/attrs/extract.ts. Kept in this shared
+ * package (not copied into mcp-core in a form the web could not later reuse)
+ * so the two can eventually converge on one implementation.
+ *
+ * The web module prefers DOMParser and falls back to this regex/tokenizer
+ * path only when DOMParser is unavailable. mcp-core runs in Node, which has
+ * no DOMParser, so it always takes that fallback path; the logic here is
+ * meant to produce the same answers as the web's fallback for the same
+ * input, not to reimplement its DOMParser branch.
+ */
+/** Ids of every `<span data-type="noteLink" data-note-id="...">` in `html`,
+ * unique, in document order. Attribute order within the tag does not matter. */
+export declare function extractLinkIds(html: string): string[];
+/** Minimal entity decoding for the no-DOMParser text extraction below,
+ * covering the common cases the editor actually emits. */
+export declare function decodeEntities(text: string): string;
+/** Flattens note HTML to plain text for mention matching: block-level
+ * closing tags and `<br>` become a space (so words either side of a block
+ * boundary do not run together), remaining tags are stripped, and entities
+ * are decoded. */
+export declare function htmlToText(html: string): string;
+export interface TitleEntry {
+    id: string;
+    title: string;
+}
+export interface TitleMatcher {
+    find(text: string, excludeIds?: Set<string>): string[];
+}
+/** Split into word tokens (letters, digits, underscore); punctuation and
+ * spaces separate. Titles are tokenized with the same tokenizer as body text
+ * so punctuation like "Follow-up", "Node.js" or "(draft)" indexes the same
+ * way it appears in prose. */
+export declare function tokenize(text: string): string[];
+/**
+ * Titles are indexed by their first lowercase token. At each token position
+ * in the text we look up only the titles that start with that token. Before
+ * doing the O(title length) positional check, a token-set pre-filter built
+ * once per `find` call rejects, in O(1) per word, any candidate whose words
+ * do not all occur somewhere in the text; a candidate that fails this
+ * pre-filter is rejected without walking its words. This keeps `find` linear
+ * in text tokens for the pre-filter, with positional work spent only on
+ * candidates that could plausibly match.
+ */
+export declare function buildTitleMatcher(entries: TitleEntry[], opts?: {
+    minLength?: number;
+}): TitleMatcher;

package/dist/cjs/attrs-extract.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Node-side twins of the web's src/lib/attrs/extract.ts. Kept in this shared
+ * package (not copied into mcp-core in a form the web could not later reuse)
+ * so the two can eventually converge on one implementation.
+ *
+ * The web module prefers DOMParser and falls back to this regex/tokenizer
+ * path only when DOMParser is unavailable. mcp-core runs in Node, which has
+ * no DOMParser, so it always takes that fallback path; the logic here is
+ * meant to produce the same answers as the web's fallback for the same
+ * input, not to reimplement its DOMParser branch.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLinkIds = extractLinkIds;
+exports.decodeEntities = decodeEntities;
+exports.htmlToText = htmlToText;
+exports.tokenize = tokenize;
+exports.buildTitleMatcher = buildTitleMatcher;
+/**
+ * Matches one opening `<span ...>` tag. A naive `[^>]*` up to the first `>`
+ * would stop inside a quoted attribute value that happens to contain a
+ * literal `>` (for example `data-note-title="A > B"`), truncating the tag
+ * and losing whatever attribute came after it, such as data-note-id. This
+ * alternates "not a quote or '>'", a double-quoted run, or a single-quoted
+ * run, so only the real closing '>' outside any quotes ends the match.
+ */
+const SPAN_TAG = /<span\b((?:[^"'>]|"[^"]*"|'[^']*')*)>/g;
+const ATTR = /([a-zA-Z_:][-\w:.]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+/** Attribute name/value pairs from inside one tag's attribute list (the
+ * captured group of SPAN_TAG), independent of the order they appear in. */
+function parseAttrs(attrString) {
+    const attrs = {};
+    for (const m of attrString.matchAll(ATTR)) {
+        attrs[m[1]] = m[2] ?? m[3] ?? '';
+    }
+    return attrs;
+}
+/** Ids of every `<span data-type="noteLink" data-note-id="...">` in `html`,
+ * unique, in document order. Attribute order within the tag does not matter. */
+function extractLinkIds(html) {
+    const ids = [];
+    const seen = new Set();
+    for (const m of html.matchAll(SPAN_TAG)) {
+        const attrs = parseAttrs(m[1] ?? '');
+        if (attrs['data-type'] !== 'noteLink')
+            continue;
+        const id = attrs['data-note-id'] ?? '';
+        if (id && !seen.has(id)) {
+            seen.add(id);
+            ids.push(id);
+        }
+    }
+    return ids;
+}
+const BLOCK_END = /<\/(p|div|h[1-6]|li|blockquote|pre|td|th|tr|section|article)>|<br\s*\/?>/gi;
+/** Minimal entity decoding for the no-DOMParser text extraction below,
+ * covering the common cases the editor actually emits. */
+function decodeEntities(text) {
+    return text
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&');
+}
+/** Flattens note HTML to plain text for mention matching: block-level
+ * closing tags and `<br>` become a space (so words either side of a block
+ * boundary do not run together), remaining tags are stripped, and entities
+ * are decoded. */
+function htmlToText(html) {
+    const spaced = html.replace(BLOCK_END, ' ');
+    return decodeEntities(spaced.replace(/<[^>]+>/g, '')).trim();
+}
+const WORD = /[\p{L}\p{N}_]/u;
+/** Split into word tokens (letters, digits, underscore); punctuation and
+ * spaces separate. Titles are tokenized with the same tokenizer as body text
+ * so punctuation like "Follow-up", "Node.js" or "(draft)" indexes the same
+ * way it appears in prose. */
+function tokenize(text) {
+    const tokens = [];
+    let current = '';
+    for (const ch of text) {
+        if (WORD.test(ch))
+            current += ch;
+        else if (current) {
+            tokens.push(current);
+            current = '';
+        }
+    }
+    if (current)
+        tokens.push(current);
+    return tokens;
+}
+/**
+ * Titles are indexed by their first lowercase token. At each token position
+ * in the text we look up only the titles that start with that token. Before
+ * doing the O(title length) positional check, a token-set pre-filter built
+ * once per `find` call rejects, in O(1) per word, any candidate whose words
+ * do not all occur somewhere in the text; a candidate that fails this
+ * pre-filter is rejected without walking its words. This keeps `find` linear
+ * in text tokens for the pre-filter, with positional work spent only on
+ * candidates that could plausibly match.
+ */
+function buildTitleMatcher(entries, opts = {}) {
+    const minLength = opts.minLength ?? 3;
+    const byFirstWord = new Map();
+    for (const { id, title } of entries) {
+        const words = tokenize(title.trim().toLowerCase());
+        if (words.length === 0)
+            continue;
+        const joinedLength = words.reduce((sum, word) => sum + word.length, 0);
+        if (joinedLength < minLength)
+            continue;
+        const list = byFirstWord.get(words[0]) ?? [];
+        list.push({ id, words });
+        byFirstWord.set(words[0], list);
+    }
+    for (const list of byFirstWord.values())
+        list.sort((a, b) => b.words.length - a.words.length);
+    return {
+        find(text, excludeIds) {
+            const tokens = tokenize(text.toLowerCase());
+            const tokenSet = new Set(tokens);
+            const found = [];
+            const seen = new Set();
+            for (let i = 0; i < tokens.length; i++) {
+                const candidates = byFirstWord.get(tokens[i]);
+                if (!candidates)
+                    continue;
+                for (const { id, words } of candidates) {
+                    if (seen.has(id) || excludeIds?.has(id))
+                        continue;
+                    let allWordsPresent = true;
+                    for (let w = 1; w < words.length; w++) {
+                        if (!tokenSet.has(words[w])) {
+                            allWordsPresent = false;
+                            break;
+                        }
+                    }
+                    if (!allWordsPresent)
+                        continue;
+                    let ok = true;
+                    for (let k = 1; k < words.length; k++) {
+                        if (tokens[i + k] !== words[k]) {
+                            ok = false;
+                            break;
+                        }
+                    }
+                    if (ok) {
+                        seen.add(id);
+                        found.push(id);
+                    }
+                }
+            }
+            return found;
+        },
+    };
+}