@glittering0717/ai-browser 2.1.2 → 2.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glittering0717/ai-browser",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "description": "AI-native browser — renders pixels for humans, structured semantic-tree API for agents. No screenshots, no OCR, no coordinate guessing.",
   "main": "src/main/index.js",
   "bin": {

package/scripts/release.cjs

@@ -48,6 +48,14 @@ function run(cmd, argv, opts = {}) {
 function git(...argv) { return run('git', argv); }
 function gitOut(...argv) { return run('git', argv).stdout.trim(); }
 
+// registry 的 github 登录可以吃环境变量，从而绕开 device flow ——
+// device flow 在无 TTY / 后台执行时会静默卡在 "Logging in..." 不打印 URL，
+// 看起来像卡死，实际是在等一个永远不会被打开的浏览器。
+function ghToken() {
+  try { return execFileSync('gh', ['auth', 'token'], { encoding: 'utf8' }).trim(); }
+  catch { return ''; }
+}
+
 const done = [];
 function mark(m) { done.push(m); }
 
@@ -160,8 +168,15 @@ if (npm.status === 0) {
   mark('npm publish');
 } else {
   const out = `${npm.stdout || ''}${npm.stderr || ''}`;
-  // token 失效的特征：whoami 401、PUT 404（npm 用 404 掩盖"没权限"）
-  if (/E401|E404|Unauthorized|Not found/i.test(out)) {
+  // 三层认证失败的表现各不相同，逐条给可执行的下一步（2026-10-23 一天踩完）：
+  //   401 / E404 on PUT  → token 过期或被撤销（npm 用 404 掩盖"没权限"）
+  //   403 + "bypass 2fa" → token 有效但建的时候没勾 Bypass 2FA
+  //   EPUBLISHCONFLICT  → 版本号已被占用
+  if (/bypass 2fa enabled is required/i.test(out)) {
+    fail('npm token 没有开 Bypass 2FA —— 账号开了 2FA 时，granular token 必须勾这个开关才能发布');
+    console.log('      https://www.npmjs.com/settings/glittering0717/tokens/new');
+    console.log('      Permissions: Read and write ｜ Scope: @glittering0717 ｜ 勾 Bypass 2FA');
+  } else if (/E401|E404|Unauthorized|Not found/i.test(out)) {
     fail('npm 认证失效（401/404）。需要重新登录一次，之后本脚本可全自动：');
     console.log('      npm login                      # 浏览器登录');
     console.log('      或：把新的 granular access token 写进 ~/.npmrc 的 //registry.npmjs.org/:_authToken');
@@ -181,17 +196,38 @@ if (!publisher) {
   warn('未找到 mcp-publisher，跳过。安装：gh release download --repo modelcontextprotocol/registry \\');
   console.log('      --pattern "mcp-publisher_darwin_arm64.tar.gz" && tar xzf ...');
 } else {
-  const pub = spawnSync(publisher, ['publish'], { cwd: ROOT, encoding: 'utf8' });
-  if (pub.status === 0) {
+  // registry 的登录态是一枚短期 JWT（几小时就过期）。过期表现是 401
+  // "token has invalid claims: token is expired" —— 不是"没登录"，
+  // 所以 `login` 会直接成功但不会有人去重跑它。这里自动续一次：
+  // MCP_GITHUB_TOKEN 让 login 走非交互路径（device flow 在无 TTY 时会静默卡住）。
+  const doPublish = () => spawnSync(publisher, ['publish'], { cwd: ROOT, encoding: 'utf8' });
+  let pub = doPublish();
+  let pubOut = `${pub.stdout || ''}${pub.stderr || ''}`;
+  if (pub.status !== 0 && /expired|invalid or expired|status 401/i.test(pubOut)) {
+    warn('registry 登录已过期，自动续期一次…');
+    const relogin = spawnSync(publisher, ['login', 'github'], {
+      cwd: ROOT,
+      encoding: 'utf8',
+      env: { ...process.env, MCP_GITHUB_TOKEN: ghToken() },
+    });
+    const reloginOut = `${relogin.stdout || ''}${relogin.stderr || ''}`;
+    if (relogin.status === 0 && /logged in/i.test(reloginOut)) {
+      ok('已重新登录');
+      pub = doPublish();
+      pubOut = `${pub.stdout || ''}${pub.stderr || ''}`;
+    } else {
+      warn('自动续期失败（需要 gh CLI 已登录）：' + reloginOut.trim().split('\n').pop());
+    }
+  }
+  if (pub.status === 0 && /successfully published/i.test(pubOut)) {
     ok('MCP registry 已发布');
     mark('mcp registry');
   } else {
-    const out = `${pub.stdout || ''}${pub.stderr || ''}`;
-    fail('MCP registry 发布失败：' + out.split('\n').filter(Boolean).slice(-6).join(' | '));
-    if (/auth|login|token|unauthor/i.test(out)) {
-      warn('需要先登录一次：mcp-publisher login github（device flow，点一下浏览器）');
+    fail('MCP registry 发布失败：' + pubOut.split('\n').filter(Boolean).slice(-6).join(' | '));
+    if (/was not found \(status: 404\)/i.test(pubOut)) {
+      warn('registry 要求 npm 上先有该版本 —— 先把 npm 那步修好，再重跑本脚本');
     }
-    warn('补救：登录后执行  mcp-publisher publish');
+    warn('补救：mcp-publisher publish');
   }
 }
 

package/src/main/page_manager.js

@@ -191,6 +191,11 @@ class PageManager {
     // 垫片登记完再导航，否则真实文档先到、垫片只对"下一次文档"生效，那个 tab
     // 就成了没有垫片的窗中窗（见 newTab 末尾长注释）。
     this._windowOpenShimReady = new Map();
+    // tabId -> 'pending' | 'loading' | 'ready' | 'blank'：这个 tab 现在处于导航的
+    // 哪一步。存在的理由：新 tab 在占位页（原先是纯白 about:blank）停留时，
+    // 光看 URL 分不清"正在加载"和"卡住了/开错了"。listTabs 把它报出去，
+    // agent 才知道该等而不是该重试。
+    this._tabNavState = new Map();
     this._axDiffCache = new Map();  // tabId -> lite interactive snapshot (get_tree {mode:'diff'})
     this._repaintTimers = new Map();// tabId -> 正在排队/已调度的重绘（合并同一批导航事件）
     this._snapshots = new Map();    // snapshotId -> { tabId, js, value, at }（ui.snapshot 存基线）
@@ -3271,6 +3276,8 @@ return {ok:true,name:file.name,size:file.size,via:via,host_sel:hostSel,clicked:c
     const wc0 = view.webContents;
     const targetUrl = url || null;
     if (wc0 && !wc0.isDestroyed()) {
+      // 还没发起真实导航：停在占位页等垫片注入。
+      this._tabNavState.set(tabId, 'pending');
       // 垫片就绪信号：先挂上去，再去加载 about:blank。顺序不能反 ——
       // ai:window_open_nav 可能在这一行之后立刻到达（IPC 保序，但它不等我们）。
       let signalReady = () => {};
@@ -3281,19 +3288,38 @@ return {ok:true,name:file.name,size:file.size,via:via,host_sel:hostSel,clicked:c
         if (proceeded) return;
         proceeded = true;
         Promise.resolve(this._ensureWindowOpenShim(tabId, view)).finally(() => {
-          // 失败也放行：宁可这个 tab 没有垫片，也不能把它卡在 about:blank。
+          // 失败也放行：宁可这个 tab 没有垫片，也不能把它卡在占位页。
           signalReady();
           if (targetUrl && wc0 && !wc0.isDestroyed()) {
+            // 让"正在加载"可被观测：白屏最贵的地方不是慢，是慢得无法和
+            // "开错了"区分（见 listTabs 的 state 字段）。
+            this._tabNavState.set(tabId, 'loading');
+            wc0.once('did-finish-load', () => {
+              if (this._tabNavState.get(tabId) === 'loading') this._tabNavState.set(tabId, 'ready');
+            });
             wc0.loadURL(targetUrl).catch(() => {});
+          } else {
+            // 无目标 URL 的占位 tab（window.open("") 的老站模式）：它本来就
+            // 要停在这里等站点赋 location，不算"卡住"，但也不是就绪。
+            this._tabNavState.set(tabId, 'blank');
           }
         });
       };
-      // 兜底：about:blank 的 did-finish-load 万一来不了（renderer 异常、
+      // 兜底：占位页的 did-finish-load 万一来不了（renderer 异常、
       // 视图尚未 attach 等），也不能把真实导航永久挂住——1.2s 后照常放行，
       // 最坏退化成"首屏没有垫片"（与修复前一致），而不是打不开页面。
       const guard = setTimeout(proceed, 1200);
       if (guard.unref) guard.unref();
-      wc0.loadURL('about:blank').catch(() => {});
+      // ⚠️ 占位页用 loading.html 而不是 about:blank（2026-10-24 修）。
+      //
+      // 这段等待原本是纯白的 about:blank。快站约 4s，慢站实测 70s（GitHub
+      // OAuth 直到 ERR_CONNECTION_TIMED_OUT 才切到错误页）—— 用户和 agent
+      // 看到的都是"弹出来一个空白页面"，和"垫片没把导航发出去"那个老 bug
+      // （超星"进入学习"）在现象上完全一样，无法区分。
+      // loading.html 只做展示（目标地址 + 转圈），不发请求不跳转，真实导航
+      // 仍由上面的 proceed 发起。无目标 URL 的占位 tab（window.open("") 的
+      // 老站模式）保持 about:blank：它本来就要停在这里等 location 赋值。
+      wc0.loadURL(this._loadingPlaceholderUrl(targetUrl)).catch(() => {});
       wc0.once('did-finish-load', () => { clearTimeout(guard); proceed(); });
     }
 
@@ -3524,6 +3550,7 @@ return {ok:true,name:file.name,size:file.size,via:via,host_sel:hostSel,clicked:c
     }
     this._windowOpenShimTabs.delete(tabId);
     this._windowOpenShimReady.delete(tabId);
+    this._tabNavState.delete(tabId);
     // Release per-tab network resources so a closed tab can never leak its
     // debugger attachment or cached request entries / stale monitors.
     this._cleanupTabResources(tabId);
@@ -3579,6 +3606,12 @@ return {ok:true,name:file.name,size:file.size,via:via,host_sel:hostSel,clicked:c
         url: view.webContents.getURL(),
         title: view.webContents.getTitle(),
         active: id === this.activeTab,
+        // 'pending' = 停在占位页等脚本注入（真实导航还没发起）
+        // 'loading' = 真实导航已发起、还没完成 —— 这时候页面多半还是空的，
+        //             是"正在打开"而不是"开错了"，等它，不要重试
+        // 'blank'   = window.open("") 的占位 tab，在等站点赋 location
+        // 'ready'   = 已就绪（没有记录时也按就绪处理）
+        state: this._tabNavState.get(id) || 'ready',
       });
     }
     return list;
@@ -3968,6 +4001,20 @@ return {ok:true,name:file.name,size:file.size,via:via,host_sel:hostSel,clicked:c
   // load about:blank，did-finish-load 后再调这里。
   // 幂等：每个 tab 只注册一次（_windowOpenShimTabs 记账）；跨导航自动保留
   // 正是 addScriptToEvaluateOnNewDocument 的语义，不需要重复注册。
+  // 新 tab 的占位页 URL：有目标地址时用 loading.html（把白屏变成可诊断的
+  // "正在打开 <url>"），无目标地址时保持 about:blank（window.open("") 的
+  // 占位 tab 要停在这里等站点赋 location，不能显示成"正在打开"）。
+  _loadingPlaceholderUrl(targetUrl) {
+    if (!targetUrl) return 'about:blank';
+    try {
+      const pagePath = path.join(__dirname, '../renderer/loading.html');
+      const q = new URLSearchParams({ url: String(targetUrl) });
+      return 'file://' + pagePath + '?' + q.toString();
+    } catch (_e) {
+      return 'about:blank';
+    }
+  }
+
   _ensureWindowOpenShim(tabId, view) {
     if (this._windowOpenShimTabs.has(tabId)) return Promise.resolve(true);
     this._windowOpenShimTabs.add(tabId);

package/src/renderer/loading.html

@@ -0,0 +1,75 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<title>正在打开…</title>
+<!--
+  loading.html — 新标签页的加载占位页。
+
+  为什么需要它：新建 tab 时必须先 load 一个真实文档才能注入 window.open 垫片
+  （CDP 命令在未导航的空 webContents 上无人处理会挂住），注入完成后才导航到
+  真实 URL。这段间隔原本是 `about:blank` —— 也就是一片纯白。网络慢时它能持续
+  几十秒（实测 GitHub OAuth 70s 才 ERR_CONNECTION_TIMED_OUT），用户和 agent
+  看到的都是"弹出来一个空白页面"，无法区分"正在加载"和"开错了"。
+
+  这个页面本身不发请求、不跑脚本，只把"正在打开哪个地址"显示出来，把白屏
+  变成一个可诊断的状态。它是纯展示：真实导航由主进程在垫片注入完成后发起。
+-->
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  html, body { height: 100%; }
+  body {
+    background: #1e1e1e;
+    color: #d4d4d4;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC', sans-serif;
+    font-size: 13px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 24px;
+  }
+  .box { max-width: 560px; width: 100%; }
+  .row { display: flex; align-items: center; gap: 10px; margin-bottom: 14px; }
+  .spinner {
+    width: 14px; height: 14px; flex: none;
+    border: 2px solid #3c3c3c;
+    border-top-color: #569cd6;
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+  }
+  @keyframes spin { to { transform: rotate(360deg); } }
+  h1 { font-size: 14px; font-weight: 600; color: #d4d4d4; }
+  .url {
+    background: #252526; border: 1px solid #3c3c3c; border-radius: 4px;
+    padding: 8px 10px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+    font-size: 12px; color: #9cdcfd; word-break: break-all; margin-bottom: 14px;
+    min-height: 34px;
+  }
+  .hint { color: #858585; font-size: 12px; line-height: 1.7; }
+</style>
+</head>
+<body>
+  <div class="box">
+    <div class="row">
+      <div class="spinner"></div>
+      <h1>正在打开…</h1>
+    </div>
+    <div class="url" id="u">about:blank</div>
+    <div class="hint">
+      新标签页需要先准备好脚本注入环境，再跳转目标地址。<br>
+      长时间停在这里通常意味着目标地址连接超时（常见于被墙或缓慢的第三方登录）。
+    </div>
+  </div>
+<script>
+  // 只做展示：把目标地址从 query 里取出来显示。
+  // 不发起任何请求、不做跳转 —— 真实导航由主进程发起，避免和它抢。
+  (function () {
+    try {
+      var q = new URLSearchParams(location.search);
+      var u = q.get('url') || '';
+      if (u) document.getElementById('u').textContent = u;
+    } catch (e) {}
+  })();
+</script>
+</body>
+</html>

package/src/renderer/tab_bar.html

@@ -18,9 +18,24 @@
   }
   /* ---- 第一行：tab 条 ---- */
   #tabs-row { display: flex; align-items: stretch; height: 36px; flex: none; }
-  #tabs { display: flex; flex: 1; overflow: hidden; }
+  /* 标签超过可视宽度时必须能横向滚动，否则后面的标签点不到、也关不掉。
+     原来是 overflow:hidden —— 超出部分被裁掉且没有任何滚动途径，标签一多
+     就等于"后半截标签永久不可用"。 */
+  #tabs {
+    display: flex; flex: 1; min-width: 0;
+    overflow-x: auto; overflow-y: hidden;
+    -webkit-app-region: no-drag;
+  }
+  /* 细滚动条：既提示"还有更多标签"，又不占视觉高度 */
+  #tabs::-webkit-scrollbar { height: 3px; }
+  #tabs::-webkit-scrollbar-track { background: transparent; }
+  #tabs::-webkit-scrollbar-thumb { background: #3a3a3a; border-radius: 2px; }
+  #tabs::-webkit-scrollbar-thumb:hover { background: #4d4d4d; }
   .tab {
     display: flex; align-items: center;
+    /* flex:none：不参与收缩。否则标签会被一路压到 min-width 再溢出，
+       配合滚动后应该保持各自宽度、让容器去滚。 */
+    flex: none;
     max-width: 200px; min-width: 80px; padding: 0 12px; height: 36px;
     cursor: pointer; border-right: 1px solid #2a2a2a;
     transition: background 0.15s;
@@ -91,7 +106,15 @@
 </div>
 
 <script>
-const { ipcRenderer } = require('electron');
+// ipcRenderer 在 Electron 主窗口里才有。直接用浏览器/测试页打开本文件时
+// require 会抛错——以前这会让整个 <script> 中断，连布局和滚动监听都不生效
+// （UI 完全死掉）。现在降级成空操作：交互没了，但标签栏仍然看得见、滚得动。
+let ipcRenderer = null;
+try { ({ ipcRenderer } = require('electron')); } catch (e) { /* 非 Electron 环境 */ }
+function send(ch, payload) { try { ipcRenderer.send(ch, payload); } catch (e) {} }
+function invoke(ch, payload) {
+  return ipcRenderer ? ipcRenderer.invoke(ch, payload) : Promise.reject(new Error('no ipc'));
+}
 
 const $ = (id) => document.getElementById(id);
 const tabsEl = $('tabs'), addrEl = $('addr'), statusEl = $('status');
@@ -115,28 +138,78 @@ function applyNavState(s) {
   addrEl.style.borderColor = s.loading ? '#e0a33e' : '';
 }
 
+let lastIds = '';      // 上次渲染的 tab id 序列 —— 只有它变了才重建 DOM
+let lastActiveId = null;
+
+// 把指定 tab 滚进可视区（只在它确实在视区外时才动，避免无谓跳动）。
+// 用 getBoundingClientRect 而不是 offsetLeft：后者依赖 offsetParent，
+// 在 flex + 滚动容器里算出来的是错的值。
+function scrollTabIntoView(id) {
+  const el = tabsEl.querySelector('.tab[data-id="' + id + '"]');
+  if (!el) return;
+  const cr = tabsEl.getBoundingClientRect(), er = el.getBoundingClientRect();
+  if (er.left < cr.left) tabsEl.scrollLeft -= (cr.left - er.left) + 8;
+  else if (er.right > cr.right) tabsEl.scrollLeft += (er.right - cr.right) + 8;
+}
+
 async function renderTabs() {
   try {
-    const tabs = await ipcRenderer.invoke('tab:list');
-    tabsEl.innerHTML = '';
-    for (const tab of tabs) {
-      const el = document.createElement('div');
-      el.className = 'tab' + (tab.active ? ' active' : '');
-      const title = (tab.title || tab.url || 'New Tab').slice(0, 30);
-      el.innerHTML = '<span class="tab-id">[' + tab.id + ']</span>' +
-        '<span class="tab-title">' + escapeHtml(title) + '</span>' +
-        '<span class="tab-close" data-id="' + tab.id + '">&times;</span>';
-      el.addEventListener('click', function (e) {
-        if (e.target.classList.contains('tab-close')) {
-          ipcRenderer.send('tab:close', parseInt(e.target.dataset.id));
-        } else {
-          ipcRenderer.send('tab:activate', tab.id);
-        }
-      });
-      tabsEl.appendChild(el);
+    const tabs = await invoke('tab:list');
+    const ids = tabs.map(function (t) { return t.id; }).join(',');
+
+    if (ids !== lastIds) {
+      // 结构变了（增/删 tab）：重建 DOM，但必须保住横向滚动位置 ——
+      // 否则在右端关掉一个标签后视图会跳回最左，后面的标签又摸不着了。
+      const prevScroll = tabsEl.scrollLeft;
+      tabsEl.innerHTML = '';
+      for (const tab of tabs) {
+        const el = document.createElement('div');
+        el.className = 'tab' + (tab.active ? ' active' : '');
+        el.dataset.id = tab.id;
+        el.innerHTML = '<span class="tab-id">[' + tab.id + ']</span>' +
+          '<span class="tab-title">' + escapeHtml((tab.title || tab.url || 'New Tab').slice(0, 30)) + '</span>' +
+          '<span class="tab-close" data-id="' + tab.id + '">&times;</span>';
+        el.addEventListener('click', function (e) {
+          // 从 this.dataset 取 id，不用闭包里的 tab —— 增量更新时闭包会过期。
+          const id = parseInt(this.dataset.id);
+          if (e.target.classList.contains('tab-close')) send('tab:close', id);
+          else send('tab:activate', id);
+        });
+        tabsEl.appendChild(el);
+      }
+      lastIds = ids;
+      tabsEl.scrollLeft = prevScroll;
+    } else {
+      // 结构没变：只改标题和激活态。绝不重建 —— 这里每 1.5s 就跑一次，
+      // 一旦重建，用户刚滚到的位置就被重置，标签一多就永远滚不回去。
+      for (let i = 0; i < tabs.length && i < tabsEl.children.length; i++) {
+        const t = tabs[i], el = tabsEl.children[i];
+        el.classList.toggle('active', !!t.active);
+        const titleEl = el.querySelector('.tab-title');
+        const title = (t.title || t.url || 'New Tab').slice(0, 30);
+        if (titleEl && titleEl.textContent !== title) titleEl.textContent = title;
+      }
     }
+
+    // 激活的 tab 换人了（含 agent 用 browse_tabs 切的情况）就把它滚进来；
+    // 已经可见时上面的计算不会产生位移。
+    const active = tabs.find(function (t) { return t.active; });
+    const activeId = active ? active.id : null;
+    if (activeId !== null && activeId !== lastActiveId) scrollTabIntoView(activeId);
+    if (activeId !== null) lastActiveId = activeId;
   } catch (e) { /* ipcRenderer 尚未就绪 */ }
 }
+
+// 横向滚动：鼠标滚轮是垂直的，标签栏要的是左右滚（浏览器惯例）。
+// overflow 改成 auto 只是"能滚"，没有这一条仍然只能拖滚动条/用触控板横扫。
+tabsEl.addEventListener('wheel', function (e) {
+  if (tabsEl.scrollWidth <= tabsEl.clientWidth) return;
+  const d = Math.abs(e.deltaY) >= Math.abs(e.deltaX) ? e.deltaY : e.deltaX;
+  if (!d) return;
+  tabsEl.scrollLeft += d;
+  e.preventDefault();
+}, { passive: false });
+
 function escapeHtml(s) {
   return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -147,27 +220,27 @@ function escapeHtml(s) {
 // 所以显示数据全部由主进程推送，本地不缓存。
 let activeTab = null;
 
-ipcRenderer.on('nav:state', (_e, s) => applyNavState(s));
+if (ipcRenderer) ipcRenderer.on('nav:state', (_e, s) => applyNavState(s));
 
-backBtn.addEventListener('click', () => ipcRenderer.send('nav:back'));
-fwdBtn.addEventListener('click', () => ipcRenderer.send('nav:forward'));
-reloadBtn.addEventListener('click', () => ipcRenderer.send('nav:reload'));
-stopBtn.addEventListener('click', () => ipcRenderer.send('nav:stop'));
+backBtn.addEventListener('click', () => send('nav:back'));
+fwdBtn.addEventListener('click', () => send('nav:forward'));
+reloadBtn.addEventListener('click', () => send('nav:reload'));
+stopBtn.addEventListener('click', () => send('nav:stop'));
 
 addrEl.addEventListener('keydown', (e) => {
   if (e.key !== 'Enter') return;
   const v = addrEl.value.trim();
   if (!v) return;
   addrEl.blur();
-  ipcRenderer.send('nav:go', v);
+  send('nav:go', v);
 });
 // 聚焦时全选，方便直接输入覆盖（浏览器惯例）
 addrEl.addEventListener('focus', () => addrEl.select());
 
-$('new-tab').addEventListener('click', () => ipcRenderer.send('tab:new'));
+$('new-tab').addEventListener('click', () => send('tab:new'));
 
 // 初始拉一次状态，然后 tab 条照旧定时刷新
-ipcRenderer.invoke('nav:state').then((s) => { if (s) applyNavState(s); });
+invoke('nav:state').then((s) => { if (s) applyNavState(s); }).catch(() => {});
 renderTabs();
 setInterval(renderTabs, 1500);
 </script>

package/src/shared/version.js

@@ -2,4 +2,4 @@
 // Kept in JS (not imported from package.json) to avoid Node import-attribute
 // (JSON module) compatibility issues inside Electron. package.json "version"
 // is manually synced to this value; tests assert they match.
-export const VERSION = '2.1.2';
+export const VERSION = '2.1.4';