bunnyquery 1.0.6 → 1.0.8

package/bunnyquery.js

@@ -66,6 +66,165 @@
     // init()) is reflected in subsequent send/auth calls.
     const _mcpBaseUrl = () => (global.BunnyQuery && global.BunnyQuery.MCP_BASE_URL) || DEFAULTS.MCP_BASE_URL;
 
+    // ----- file-fence helpers (mirrors agent.vue) ---------------------------
+    // Bare language tags we treat as downloadable files. Maps to the
+    // extension used in the synthesized filename. Mirrors the file types the
+    // host agent (agent.vue) is known to emit as ```filename.ext fences.
+    const FENCE_LANGUAGE_EXTENSIONS = {
+        html: 'html',
+        htm: 'html',
+        csv: 'csv',
+        tsv: 'tsv',
+        json: 'json',
+        xml: 'xml',
+        svg: 'svg',
+        md: 'md',
+        markdown: 'md',
+        yaml: 'yaml',
+        yml: 'yml',
+        txt: 'txt',
+        sql: 'sql',
+        css: 'css',
+    };
+
+    const FENCE_MIME_TYPES = {
+        html: 'text/html',
+        csv: 'text/csv',
+        tsv: 'text/tab-separated-values',
+        json: 'application/json',
+        xml: 'application/xml',
+        svg: 'image/svg+xml',
+        md: 'text/markdown',
+        yaml: 'text/yaml',
+        yml: 'text/yaml',
+        txt: 'text/plain',
+        sql: 'application/sql',
+        css: 'text/css',
+    };
+
+    // Closed fences with `filename.ext` after the opening backticks.
+    const FENCE_FILENAME_RE = /```([\w.-]+\.[a-zA-Z0-9]+)\n([\s\S]*?)```/g;
+    // Closed fences whose info-string is one of the known language tags
+    // above. The model often emits ```html ... ``` or ```csv ... ``` instead
+    // of a full filename — surface those as downloadable files too.
+    const FENCE_LANG_RE = new RegExp(
+        '```(' + Object.keys(FENCE_LANGUAGE_EXTENSIONS).join('|') + ')[ \\t]*\\n([\\s\\S]*?)```',
+        'gi'
+    );
+    // Open (still-streaming) fences for either pattern, used to suppress the
+    // raw fence text mid-typewriter.
+    const OPEN_FENCE_FILENAME_RE = /```([\w.-]+\.[a-zA-Z0-9]+)\n?/;
+    const OPEN_FENCE_LANG_RE = new RegExp(
+        '```(' + Object.keys(FENCE_LANGUAGE_EXTENSIONS).join('|') + ')[ \\t]*\\n?',
+        'i'
+    );
+
+    // Cache blob URLs keyed by (filename + content) so re-renders don't leak
+    // a fresh ObjectURL on every tick of streaming text.
+    const _fileBlobCache = new Map();
+    const _getOrCreateFileHref = (filename, body) => {
+        const key = filename + '\u0000' + body;
+        const existing = _fileBlobCache.get(key);
+        if (existing) return existing;
+        const ext = (filename.split('.').pop() || '').toLowerCase();
+        const type = FENCE_MIME_TYPES[ext] || 'text/plain';
+        const blob = new Blob([body], { type });
+        const href = URL.createObjectURL(blob);
+        _fileBlobCache.set(key, href);
+        return href;
+    };
+
+    // Counter used to mint stable filenames for bare-language fences within
+    // a single rendered message ("download.html", "download-2.html", ...).
+    // Keyed by message identity so re-renders of the same message reuse the
+    // same names (which lets the blob cache hit).
+    const _bareFenceNameCounters = new WeakMap();
+    const _bareFilenameFor = (msgKey, ext, occurrence) => {
+        const base = 'download';
+        return occurrence === 0 ? `${base}.${ext}` : `${base}-${occurrence + 1}.${ext}`;
+    };
+
+    // Split message content into a sequence of {type:'text'|'file'} parts,
+    // mirroring agent.vue's parseMsgParts behavior for fenced code blocks.
+    // Bare-language fences (```html, ```csv, ...) are also lifted into
+    // downloadable file parts with a synthesized filename.
+    const parseMsgParts = (content, msgKey, isTyping) => {
+        const parts = [];
+        if (!content) return parts;
+
+        // Combine matches from both fence regexes, sorted by position.
+        const matches = [];
+        FENCE_FILENAME_RE.lastIndex = 0;
+        let mm;
+        while ((mm = FENCE_FILENAME_RE.exec(content)) !== null) {
+            matches.push({ index: mm.index, length: mm[0].length, filename: mm[1], body: mm[2], kind: 'filename' });
+        }
+        FENCE_LANG_RE.lastIndex = 0;
+        let bareCounters = _bareFenceNameCounters.get(msgKey);
+        if (!bareCounters) {
+            bareCounters = {};
+            if (msgKey) _bareFenceNameCounters.set(msgKey, bareCounters);
+        }
+        const bareSeen = {};
+        while ((mm = FENCE_LANG_RE.exec(content)) !== null) {
+            const lang = mm[1].toLowerCase();
+            const ext = FENCE_LANGUAGE_EXTENSIONS[lang];
+            const occurrence = bareSeen[ext] || 0;
+            bareSeen[ext] = occurrence + 1;
+            matches.push({
+                index: mm.index,
+                length: mm[0].length,
+                filename: _bareFilenameFor(msgKey, ext, occurrence),
+                body: mm[2],
+                kind: 'lang',
+            });
+        }
+        // If both regexes matched the same span (a `filename.ext` fence is
+        // also a bare-language fence when the language coincides), prefer
+        // the filename match.
+        matches.sort((a, b) => a.index - b.index || (a.kind === 'filename' ? -1 : 1));
+        const dedup = [];
+        for (const m of matches) {
+            if (dedup.length && dedup[dedup.length - 1].index === m.index) continue;
+            dedup.push(m);
+        }
+
+        let last = 0;
+        for (const m of dedup) {
+            if (m.index > last) {
+                parts.push({ type: 'text', text: content.slice(last, m.index) });
+            }
+            parts.push({
+                type: 'file',
+                filename: m.filename,
+                href: _getOrCreateFileHref(m.filename, m.body),
+            });
+            last = m.index + m.length;
+        }
+
+        let tail = content.slice(last);
+
+        // Mid-typewriter: hide raw source for a still-open fence so the user
+        // doesn't watch literal code stream by character-by-character.
+        if (isTyping && tail) {
+            const fnOpen = tail.match(OPEN_FENCE_FILENAME_RE);
+            const langOpen = tail.match(OPEN_FENCE_LANG_RE);
+            const open = fnOpen && (!langOpen || fnOpen.index <= langOpen.index)
+                ? { match: fnOpen, label: fnOpen[1] }
+                : langOpen
+                    ? { match: langOpen, label: 'download.' + FENCE_LANGUAGE_EXTENSIONS[langOpen[1].toLowerCase()] }
+                    : null;
+            if (open) {
+                const before = tail.slice(0, open.match.index);
+                if (before) parts.push({ type: 'text', text: before });
+                parts.push({ type: 'text', text: `\n[generating ${open.label}...]` });
+                tail = '';
+            }
+        }
+        if (tail) parts.push({ type: 'text', text: tail });
+        return parts;
+    };
+
     // ----- helpers ----------------------------------------------------------
     const $ = (tag, attrs, children) => {
         const el = document.createElement(tag);
@@ -492,6 +651,50 @@
         return 'Request failed. Please try again.';
     }
 
+    // Detect MCP / upstream "your access token is no longer valid" failures
+    // so we can transparently re-mint the MCP token from the live skapi
+    // session and retry the call once. Patterns observed in the wild:
+    //   - skapi-js inside the MCP server throws "Token has expired"
+    //     (surfaces here as part of err.message or response body text)
+    //   - MCP returns OAuth-style error codes: invalid_token / expired_token
+    //   - Proxy wraps it with INVALID_REQUEST + 401
+    function _isAuthExpiredError(input) {
+        if (!input) return false;
+        const blobs = [];
+        const push = (v) => { if (typeof v === 'string' && v) blobs.push(v); };
+        if (typeof input === 'string') push(input);
+        else {
+            push(input.message);
+            push(input.code);
+            if (input.error) {
+                push(input.error.message);
+                push(input.error.code);
+                push(input.error.type);
+            }
+            if (input.body) {
+                push(input.body.message);
+                if (input.body.error) {
+                    push(input.body.error.message);
+                    push(input.body.error.code);
+                    push(input.body.error.type);
+                }
+            }
+            if (typeof input.status === 'number' && input.status === 401) return true;
+            if (typeof input.status_code === 'number' && input.status_code === 401) return true;
+        }
+        const hay = blobs.join(' | ').toLowerCase();
+        if (!hay) return false;
+        return (
+            hay.includes('token has expired') ||
+            hay.includes('token is expired') ||
+            hay.includes('expired_token') ||
+            hay.includes('invalid_token') ||
+            hay.includes('unauthorized') ||
+            hay.includes('not authorized') ||
+            (hay.includes('invalid_request') && hay.includes('token'))
+        );
+    }
+
     // Mirror of agent.vue's isErrorResponseBody — detects provider/proxy
     // error payloads that should render as a red error bubble even when
     // no exception was thrown.
@@ -872,7 +1075,29 @@
                 if (msg.isPending) {
                     bubble.appendChild($('span', { class: 'bq-loader' }, 'Thinking'));
                 } else {
-                    bubble.textContent = msg.content || '';
+                    // Render fenced file blocks (```filename.ext``` or
+                    // ```html / ```csv / etc.) as inline download links;
+                    // everything else stays plain text. Mirrors the
+                    // behavior of agent.vue's parseMsgParts.
+                    const parts = parseMsgParts(msg.content || '', msg, !!this.typing);
+                    if (!parts.length) {
+                        bubble.textContent = msg.content || '';
+                    } else {
+                        for (const part of parts) {
+                            if (part.type === 'file') {
+                                const a = $('a', {
+                                    class: 'bq-file-download',
+                                    href: part.href,
+                                    target: '_blank',
+                                    rel: 'noopener noreferrer',
+                                    download: part.filename,
+                                }, '\u2197 ' + part.filename);
+                                bubble.appendChild(a);
+                            } else {
+                                bubble.appendChild(document.createTextNode(part.text));
+                            }
+                        }
+                    }
                 }
                 const wrapper = $('div', {
                     class:
@@ -1090,12 +1315,24 @@
 
         // ---- history ------------------------------------------------------
         async _loadFirstHistoryPage() {
+            const fetchPage = () => getChatHistory(
+                this.skapi,
+                { service: this.serviceId, owner: this.ownerId, platform: this.platform },
+                { ascending: false }
+            );
             try {
-                const res = await getChatHistory(
-                    this.skapi,
-                    { service: this.serviceId, owner: this.ownerId, platform: this.platform },
-                    { ascending: false }
-                );
+                let res;
+                try {
+                    res = await fetchPage();
+                } catch (err) {
+                    if (_isAuthExpiredError(err)) {
+                        this.oauth.clearToken();
+                        await this.oauth.exchangeSession(this.skapi.session);
+                        res = await fetchPage();
+                    } else {
+                        throw err;
+                    }
+                }
                 this.startKeyHistory = res && res.startKeyHistory;
                 const list = this._filterByClearHorizon((res && res.list) || []);
                 // If the clear horizon has filtered the entire first page,
@@ -1374,13 +1611,42 @@ The same pattern applies to other formats: \`\`\`my-data.json, \`\`\`index.html,
                     model: this.model || undefined,
                 };
 
-                const result = this.platform === 'claude'
-                    ? await buildClaudeRequest(this.skapi, args)
-                    : await buildOpenAIRequest(this.skapi, args);
+                const argsBuilder = () => (this.platform === 'claude'
+                    ? buildClaudeRequest(this.skapi, args)
+                    : buildOpenAIRequest(this.skapi, args));
+
+                let result;
+                try {
+                    result = await argsBuilder();
+                } catch (err) {
+                    if (_isAuthExpiredError(err)) {
+                        // The MCP-side skapi session expired. Re-mint a fresh
+                        // MCP token bundle from the live host skapi session
+                        // (skapi-js auto-refreshes its own tokens), then retry
+                        // the call once.
+                        try {
+                            this.oauth.clearToken();
+                            await this.oauth.exchangeSession(this.skapi.session);
+                        } catch (reauthErr) {
+                            throw reauthErr;
+                        }
+                        result = await argsBuilder();
+                    } else {
+                        throw err;
+                    }
+                }
 
                 // The proxy may resolve with an error-shaped body instead of
                 // throwing; surface that as an error bubble with the
                 // upstream message rather than dropping it.
+                if (isErrorResponseBody(result) && _isAuthExpiredError(result)) {
+                    try {
+                        this.oauth.clearToken();
+                        await this.oauth.exchangeSession(this.skapi.session);
+                        result = await argsBuilder();
+                    } catch (_reauthErr) { /* fall through to normal error rendering */ }
+                }
+
                 if (isErrorResponseBody(result)) {
                     const errMsg = getErrorMessage(result);
                     const last = this.messages[this.messages.length - 1];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunnyquery",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "BunnyQuery AI chat client",
   "main": "bunnyquery.js",
   "files": [