magpie-gemini-web 0.4.0 → 0.4.1

package/README.en.md

@@ -4,10 +4,12 @@
 
 Use Gemini on the web through your Google account in [Magpie](https://usemagpie.ai/). The plugin runs the [gemini-web2api-go](https://github.com/zexadev/gemini-web2api-go) backend on your machine. The backend turns the Gemini web app into an OpenAI-compatible API.
 
+> **2026-10-16 update:** Full-price Google AI Pro accounts can now use `gemini-4-argon` directly in Antigravity, and can likewise be proxied directly with Magpie.
+
 ## Getting started
 
 1. Install **magpie-gemini-web** from the Magpie plugin market.
-2. Sign in to Gemini Web and choose **一键配置本地 Gemini Web (one-click local setup, recommended)**. The plugin downloads the backend, verifies it and starts it in the background.
+2. Sign in to Gemini Web and choose **一键配置本地 Gemini Web (one-click local setup, recommended)**. The plugin downloads this project's optimized backend, verifies its SHA-256 and starts it in the background. No Go installation or manual patching is needed.
 3. Copy your cookie when prompted. **Use a private / incognito window** (Firefox recommended):
    1. In the private window, open <https://gemini.google.com/app> and sign in to the Google account you want to use.
    2. Press F12 (⌥⌘I on macOS), switch to **Network** and reload the page.
@@ -48,7 +50,7 @@ You can switch a model between `low` and `high` effort in Magpie if it has a `-t
 ## Security and data
 
 - The backend listens on `127.0.0.1` only. Your cookie goes only to that local backend, and Magpie stores a locally generated API key instead.
-- The plugin pins the official v4.22.0 backend binary and checks its SHA-256 on download and on every start. Builds are available for macOS, Linux and Windows on x64 and arm64.
+- The default backend is this project's **4.22.0-magpie.1**, built from pinned upstream v4.22.0 sources with this repository's patch. SHA-256 is checked on download and before launching a new process. Builds cover macOS, Linux and Windows on x64 and arm64; the release includes sources, build metadata and checksums.
 - The data directory is `~/.local/share/magpie-gemini-web` (set `GEMINI_WEB_DATA_DIR` to change it). The backend writes its log to `backend.log` there.
 - The plugin sends one request at a time, but this can't guarantee that Google won't flag your account. Use it at your own risk.
 
@@ -79,32 +81,36 @@ So with a proxy pool, an account just added by one-click setup has no email yet.
 
 On macOS, sign-in offers one more option, "macOS 原生 Task（实验性）": requests skip the Gemini Web backend and go to a local daemon that runs them in Gemini.app's own Task mode, with tool calls on its native Function Calling channel, as the model `gemini-task-argon`. Windows and Linux don't offer it; keep using one-click setup there.
 
-This is an alpha: it supports only the verified Gemini.app build, needs a local setup first (Gemini.app signed in, plus session templates), hasn't passed an end-to-end check against real Argon yet, and shows no usage. See [native-task/README.md](native-task/README.md) for setup, session requirements and limitations.
+This is an alpha: it supports only the verified Gemini.app build, needs a local setup first (Gemini.app signed in, plus session templates), has passed only one live tool round trip against real Argon, and shows no usage; if an agent is interrupted before it returns a tool result, that call holds the only Task slot for up to about 4 minutes. See [native-task/README.md](native-task/README.md) for setup, session requirements and limitations.
+
+## Default optimized backend and rollback
+
+Starting with plugin **0.4.1**, one-click setup uses [4.22.0-magpie.1](https://github.com/BUKOWSKIREAL/magpie-gemini-web/releases/tag/backend-v4.22.0-magpie.1). It includes the changes that previously required a manual build: stable XSRF caching, cancellation propagation for the main generation and upload requests, early completion after complete tool calls, browser headers, and verification of the returned Argon model. Your Google account still needs access to the requested model.
+
+**Upgrading an existing installation:** the plugin leaves a running backend alone. Stop the existing backend process (its process ID is in `backend.pid` in the data directory), then start Magpie or send a request. A stopped old official backend is upgraded automatically, preserving configuration, the cookie database and API keys. Explicitly installed local Argon builds are kept; to replace one with the published build, stop it and run `backend:install` below.
 
-## Argon patched build (optional)
+To roll back, stop the backend and run this from the plugin directory:
 
-The official backend already supports `gemini-4-argon`, which needs a paid or Ultra account. This repo's patched build also verifies that responses really come from Argon, so a silent downgrade is caught, and it lowers latency. It also makes the backend's requests look more like a browser's: on a direct connection every request carries the full set of Chrome headers (the official build's direct chat requests say `Go-http-client/2.0`), and refreshing the cookies to keep a session alive no longer fetches the `/app` page right away. Building it requires Go 1.26+:
+```bash
+npm run backend:install:upstream
+```
+
+This installs the checksum-verified official v4.22.0 and saves the selection, so automatic starts keep using upstream. To restore the default optimized build:
 
 ```bash
-git clone https://github.com/BUKOWSKIREAL/magpie-gemini-web.git && cd magpie-gemini-web
-git clone https://github.com/zexadev/gemini-web2api-go.git backend-source
-git -C backend-source checkout a65b1d1a5ac614c1b455857334b4f1c73ab8fcfb
-git -C backend-source apply ../patches/argon.patch
-npm run backend:build:argon
-npm run backend:install:argon
+npm run backend:install
 ```
 
-Restart Magpie when the install finishes, and the plugin starts the Argon build in the background. If an older backend is still running, stop it first with `kill $(cat ~/.local/share/magpie-gemini-web/backend.pid)`. Run `npm run backend:install` to switch back to the official build.
+A failed download or checksum verification keeps the previous binary. On Windows, stop the old process before replacing its executable.
 
-When `patches/argon.patch` changes (after you pull a new version of this repo, say), apply it again to clean sources and rebuild. Once the old backend is stopped, the plugin starts the new one on the next request:
+The backend release includes source and build metadata. Developers with Git, Node 22+ and Go 1.27.1 can reproduce all six builds and compare the pinned hashes from this repository:
 
 ```bash
-git -C backend-source checkout -- . && git -C backend-source clean -fdq
-git -C backend-source apply ../patches/argon.patch
-npm run backend:build:argon && npm run backend:install:argon
-kill $(cat ~/.local/share/magpie-gemini-web/backend.pid)
+npm run backend:release:build
 ```
 
+The script extracts clean sources from the pinned upstream commit and applies `patches/argon.patch`; it never changes the developer's `backend-source` working tree. See [docs/backend-release.md](docs/backend-release.md) for the release procedure.
+
 ## License
 
 MIT. The upstream gemini-web2api-go project is also MIT (see `LICENSE-UPSTREAM`).

package/README.md

@@ -4,10 +4,12 @@
 
 让 [Magpie](https://usemagpie.ai/) 通过你的 Google 账号使用 Gemini 网页版。插件在本机运行 [gemini-web2api-go](https://github.com/zexadev/gemini-web2api-go) 后端，把 Gemini 网页转成 OpenAI 兼容接口。
 
+> **2026-10-16 更新**：现在正价支付的 Google AI Pro 可以直接在 Antigravity 中使用 `gemini-4-argon`，同理也可以直接用 Magpie 反代。
+
 ## 开始使用
 
 1. 在 Magpie 插件市场安装 **magpie-gemini-web**。
-2. 登录 Gemini Web，选 **「一键配置本地 Gemini Web（推荐）」**。插件会自动下载并校验后端，在后台启动它。
+2. 登录 Gemini Web，选 **「一键配置本地 Gemini Web（推荐）」**。插件会自动下载本项目发布的优化后端、校验 SHA-256，并在后台启动；不需要安装 Go 或手动打补丁。
 3. 按提示复制 Cookie，**一定要用无痕 / 隐私窗口**（推荐 Firefox）：
    1. 在无痕窗口打开 <https://gemini.google.com/app>，登录要使用的 Google 账号；
    2. 按 F12（macOS 按 ⌥⌘I），切到 **Network（网络）**，刷新页面；
@@ -48,7 +50,7 @@ magpie plugin options magpie-gemini-web '{"allowImages":true}'
 ## 安全与数据
 
 - 后端只监听 `127.0.0.1`；Cookie 只交给本机后端，Magpie 保存的是本地生成的 API key。
-- 后端二进制锁定官方 v4.22.0，下载和每次启动都校验 SHA-256。支持 macOS、Linux、Windows（x64 / arm64）。
+- 默认后端为本项目发布的 **4.22.0-magpie.1**，基于固定的上游 v4.22.0 源码应用本仓库补丁。下载和启动新进程前校验 SHA-256。支持 macOS、Linux、Windows（x64 / arm64），发布页提供源码、构建记录和校验和。
 - 数据目录：`~/.local/share/magpie-gemini-web`（可用 `GEMINI_WEB_DATA_DIR` 修改），日志在 `backend.log`。
 - 插件限制并发为 1，但无法保证账号不被 Google 风控，请自行承担风险。
 
@@ -79,32 +81,36 @@ Magpie 的额度卡片会显示 Google 账号的 **5 小时** 和 **每周** 用
 
 在 macOS 上登录时会多出一个「macOS 原生 Task（实验性）」选项：请求不走 Gemini Web 后端，而是交给本机常驻服务，由 Gemini.app 自己的 Task 模式执行，工具调用走原生的 Function Calling 通道，模型为 `gemini-task-argon`。Windows 和 Linux 上不会出现这个选项，请继续使用上面的一键配置。
 
-当前为 Alpha：仅支持已验证的 Gemini.app 版本，选这个选项之前需要先在本机完成 setup（需要 Gemini.app 已登录，以及会话模板），尚未完成真实 Argon 的端到端验收，读不到额度。配置步骤、会话要求和限制见 [native-task/README.md](native-task/README.md)。
+当前为 Alpha：仅支持已验证的 Gemini.app 版本，选这个选项之前需要先在本机完成 setup（需要 Gemini.app 已登录，以及会话模板），只完成过一次真实 Argon 的工具往返验证，读不到额度；Agent 中途打断时，未回传结果的工具调用会占住唯一的 Task 名额最长约 4 分钟。配置步骤、会话要求和限制见 [native-task/README.md](native-task/README.md)。
+
+## 默认优化后端与回退
+
+从插件 **0.4.1** 起，一键配置默认使用 [4.22.0-magpie.1](https://github.com/BUKOWSKIREAL/magpie-gemini-web/releases/tag/backend-v4.22.0-magpie.1)。它包含原先需要手动编译的优化：稳定的 XSRF 缓存、主要生成与上传请求的取消传播、完整工具调用后的提前收尾、浏览器请求头，以及 Argon 返回模型校验。Google 账号仍需具备对应模型权限。
+
+**已有用户升级**：插件不会中断正在运行的后端。先停止现有后端进程（进程 ID 在数据目录的 `backend.pid`），再启动 Magpie 或发送请求；停止状态的旧官方后端会自动更新，配置、Cookie 数据库和 API key 保留。已经手动安装的本地 Argon 构建会继续复用；要切到发布版，可在停止后端后运行下面的 `backend:install`。
 
-## Argon 增强版（可选）
+需要回退时，在插件目录停止后端后运行：
 
-官方后端已支持 `gemini-4-argon`（需付费 / Ultra 账号）。本仓库的补丁版额外校验返回的确实是 Argon（防止被静默降级），并降低延迟。它也让后端的请求更像浏览器：直连时每个请求都带齐 Chrome 请求头（官方版直连时，对话请求的 UA 是 `Go-http-client/2.0`），保活刷新 Cookie 后也不再立即重新抓取 `/app` 页面。需要 Go 1.26+：
+```bash
+npm run backend:install:upstream
+```
+
+这会安装经过 SHA-256 校验的官方 v4.22.0，并记住回退选择，之后自动启动也使用官方版。恢复默认优化版：
 
 ```bash
-git clone https://github.com/BUKOWSKIREAL/magpie-gemini-web.git && cd magpie-gemini-web
-git clone https://github.com/zexadev/gemini-web2api-go.git backend-source
-git -C backend-source checkout a65b1d1a5ac614c1b455857334b4f1c73ab8fcfb
-git -C backend-source apply ../patches/argon.patch
-npm run backend:build:argon
-npm run backend:install:argon
+npm run backend:install
 ```
 
-安装后重启 Magpie 即可，插件会在后台启动 Argon 版（如有旧后端在运行，先 `kill $(cat ~/.local/share/magpie-gemini-web/backend.pid)`）。运行 `npm run backend:install` 可切回官方版。
+下载失败或校验不通过时保留旧二进制。Windows 上必须先停止旧进程，才能替换正在使用的可执行文件。
 
-`patches/argon.patch` 更新后（比如拉取了本仓库的新版本），需要在干净的源码上重新应用补丁并重新构建。停掉旧后端后，插件会在下一个请求时启动新版：
+源码与构建记录随后端 Release 提供。开发者使用 Git、Node 22+、Go 1.27.1，可从本仓库复现全部六个平台的构建并核对哈希：
 
 ```bash
-git -C backend-source checkout -- . && git -C backend-source clean -fdq
-git -C backend-source apply ../patches/argon.patch
-npm run backend:build:argon && npm run backend:install:argon
-kill $(cat ~/.local/share/magpie-gemini-web/backend.pid)
+npm run backend:release:build
 ```
 
+构建脚本从固定的上游提交提取干净源码、应用 `patches/argon.patch`，不会修改本地 `backend-source` 的工作内容。发布流程见 [docs/backend-release.md](docs/backend-release.md)。
+
 ## 友链
 
 [LINUX DO](https://linux.do/) — 真诚、友善、团结、专业的技术社区。

package/docs/backend-release.md

@@ -0,0 +1,31 @@
+# Backend releases
+
+The plugin's default backend is built from the upstream commit and toolchain recorded in `lib/backend-release.json`, with `patches/argon.patch` applied. The builder overrides the backend's displayed version with the release version. Six binaries are pinned by SHA-256 in the same JSON file. The build does not include the developer's uncommitted backend sources, local data or credentials.
+
+For a new backend release:
+
+1. Choose a new backend version and tag in `lib/backend-release.json`. Never replace files under an already published backend tag: older plugins pin those hashes. Update the upstream commit or patch when needed.
+2. Run `node scripts/backend-release.mjs --write-pins`. It extracts a clean upstream tree, applies the patch, runs Go tests, cross-compiles all six targets and writes the resulting pins. It uses a local `backend-source` Git object database if available; otherwise it fetches the pinned public commit in a temporary directory.
+3. Run `npm test` and `node scripts/backend-smoke.mjs`. The smoke test uses a temporary data directory, checks the actual executable's version and hash, starts it on a spare loopback port, checks authentication and model discovery, and verifies reuse. It uses no Google account and takes the tokenizer's offline fallback.
+4. Commit the release metadata, installer changes, tests and documentation. Run the **Verify backend release** GitHub Actions workflow at that commit. It rebuilds on native macOS, Linux and Windows runners for both architectures, compares the pinned hashes, and runs the installation/startup smoke test. Wait for all jobs to pass.
+5. Create a private draft under the pinned backend tag. Attach all six binaries, `SHA256SUMS.txt`, `build.json`, the patched source archive and `LICENSE-UPSTREAM` from `backend-build/release`. If local binary uploads are unreliable, run **Upload verified backend release** with the successful verification run ID: it downloads the six CI artifacts, checks every committed hash, and uploads missing executables to the draft. Existing assets must match exactly; published releases cannot be modified by this workflow. Include the upstream commit and patch SHA-256 in the release notes, then publish the complete draft. Keep backend-only releases from replacing the plugin release as GitHub's latest release.
+6. Verify public asset downloads against the committed pins. Run `node scripts/backend-smoke.mjs --download` to test the actual default download URL on the host platform.
+7. Bump and publish the plugin package only after the backend assets are publicly available. Inspect `npm pack --dry-run`; the npm package contains release metadata and patch/build scripts, but no executables, local databases or credentials. Attach the exact published npm tarball to the plugin's GitHub release as well.
+
+Reproduce a release without changing its pins:
+
+```bash
+npm run backend:release:build
+```
+
+Build just the host target and compare its hash:
+
+```bash
+node scripts/backend-release.mjs --target=host --verify
+```
+
+The metadata records `CGO_ENABLED=0`, the exact Go toolchain, upstream commit, patch hash and build flags. The binary hashes are reproducible; the source archive is supplied for inspection and is not promised to have a reproducible gzip timestamp. The source archive includes upstream's license, and `LICENSE-UPSTREAM` is also supplied as a separate asset.
+
+Existing running processes are left alone to avoid interrupting requests. Once an old official backend is stopped, automatic startup installs the optimized build while preserving configuration, secrets and the database. A download or checksum failure keeps the old file and never starts an unverified replacement.
+
+An explicit `npm run backend:install:upstream` installs the pinned upstream v4.22.0 and persists `upstream` in `backend-channel.json`. Automatic startup respects that choice. `npm run backend:install` returns to the optimized channel. Stop a running backend before replacing it, particularly on Windows. Explicit local Argon builds remain trusted through their existing build manifest.

package/lib/backend-release.json

@@ -0,0 +1,36 @@
+{
+  "version": "4.22.0-magpie.1",
+  "repository": "BUKOWSKIREAL/magpie-gemini-web",
+  "tag": "backend-v4.22.0-magpie.1",
+  "upstream": {
+    "repository": "https://github.com/zexadev/gemini-web2api-go.git",
+    "commit": "a65b1d1a5ac614c1b455857334b4f1c73ab8fcfb"
+  },
+  "goVersion": "1.27.1",
+  "binaries": {
+    "darwin-arm64": {
+      "asset": "gemini-web2api-go_v4.22.0-magpie.1_darwin_arm64",
+      "sha256": "833dd54e7c0df927afc1d4e0f6443bcc03b7f0a4d04d24cdfde47d5dd27349c5"
+    },
+    "darwin-x64": {
+      "asset": "gemini-web2api-go_v4.22.0-magpie.1_darwin_amd64",
+      "sha256": "d65b053a0e5f8e1065ea35835b3a7d12f783d97964c02bef49679df7ead92fd4"
+    },
+    "linux-x64": {
+      "asset": "gemini-web2api-go_v4.22.0-magpie.1_linux_amd64",
+      "sha256": "94f082e666b34051f191959de3f2cd601078d117b1d3ededcdcd6b2201c48ef9"
+    },
+    "linux-arm64": {
+      "asset": "gemini-web2api-go_v4.22.0-magpie.1_linux_arm64",
+      "sha256": "4a7cbca2771acc9e836a5a986e11b3b247baf77e9900262cb588b515a1161aaa"
+    },
+    "win32-x64": {
+      "asset": "gemini-web2api-go_v4.22.0-magpie.1_windows_amd64.exe",
+      "sha256": "61d279d50c6c09ffe81ed059a557077900948d0ae598e4c4b3a5d5c213ad5e5c"
+    },
+    "win32-arm64": {
+      "asset": "gemini-web2api-go_v4.22.0-magpie.1_windows_arm64.exe",
+      "sha256": "20bad088b114d3dc989830ff35f7e56c1e0026caf9721b739fe982f5fd3d1880"
+    }
+  }
+}

package/lib/native.mjs

@@ -3,12 +3,16 @@ import path from 'node:path';
 import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
+import release from './backend-release.json' with { type: 'json' };
 
-export const BACKEND_VERSION = 'v4.22.0';
-const RELEASE_BASE = `https://github.com/zexadev/gemini-web2api-go/releases/download/${BACKEND_VERSION}/`;
+export const BACKEND_VERSION = `v${release.version}`;
+const RELEASE_BASE = `https://github.com/${release.repository}/releases/download/${release.tag}/`;
+export const PINNED_BINARIES = release.binaries;
 
-// Upstream release assets by `${process.platform}-${process.arch}`, SHA-256 from the release's SHA256SUMS.txt.
-export const PINNED_BINARIES = {
+const UPSTREAM_VERSION = 'v4.22.0';
+const UPSTREAM_BASE = `https://github.com/zexadev/gemini-web2api-go/releases/download/${UPSTREAM_VERSION}/`;
+// Retained for an explicit, checksum-verified rollback to the upstream release.
+export const UPSTREAM_BINARIES = {
   'darwin-arm64': { asset: 'gemini-web2api-go_v4.22.0_darwin_arm64', sha256: 'c69ca75cf43017cf2a62dbf5c12b07f6bde66f403f714c32209b1ad350ed24c9' },
   'darwin-x64': { asset: 'gemini-web2api-go_v4.22.0_darwin_amd64', sha256: '384e617bcc30aacac6b7c4e4d0490e88d282b13b29f7a0a20d645b69514cd405' },
   'linux-x64': { asset: 'gemini-web2api-go_v4.22.0_linux_amd64', sha256: '21fcc81e0ad8ce0921e6b6c2cafce1089852530142b37e0289355c6e72df5299' },
@@ -17,12 +21,38 @@ export const PINNED_BINARIES = {
   'win32-arm64': { asset: 'gemini-web2api-go_v4.22.0_windows_arm64.exe', sha256: 'b42e951bfc08d7fe8bdb436dca87fc6a1b7948bb8d10e110653bcf13a790756c' }
 };
 
-export function pinnedBinary(platform = process.platform, arch = process.arch) {
-  const pin = PINNED_BINARIES[`${platform}-${arch}`];
+export function pinnedBinary(platform = process.platform, arch = process.arch, channel = 'optimized') {
+  if (channel !== 'optimized' && channel !== 'upstream') throw new Error(`Invalid backend channel: ${channel}`);
+  const pins = channel === 'upstream' ? UPSTREAM_BINARIES : PINNED_BINARIES;
+  const base = channel === 'upstream' ? UPSTREAM_BASE : RELEASE_BASE;
+  const version = channel === 'upstream' ? UPSTREAM_VERSION : BACKEND_VERSION;
+  const pin = pins[`${platform}-${arch}`];
   if (!pin) {
-    throw new Error(`No gemini-web2api-go ${BACKEND_VERSION} build for ${platform}/${arch}. Download one manually from https://github.com/zexadev/gemini-web2api-go/releases/tag/${BACKEND_VERSION}`);
+    throw new Error(`No gemini-web2api-go ${version} build for ${platform}/${arch}. See ${base.slice(0, -1).replace('/download/', '/tag/')}`);
+  }
+  return { url: base + pin.asset, sha256: pin.sha256 };
+}
+
+export function backendChannel(dataDir = getDataDir()) {
+  try {
+    const { channel } = JSON.parse(fs.readFileSync(path.join(dataDir, 'backend-channel.json'), 'utf8'));
+    if (channel !== 'optimized' && channel !== 'upstream') throw new Error('Expected optimized or upstream');
+    return channel;
+  } catch (error) {
+    if (error.code === 'ENOENT') return 'optimized';
+    throw new Error(`Invalid backend-channel.json: ${error.message}`);
+  }
+}
+
+function saveBackendChannel(dataDir, channel) {
+  const file = path.join(dataDir, 'backend-channel.json');
+  const temp = `${file}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+  try {
+    fs.writeFileSync(temp, JSON.stringify({ channel }) + '\n', { mode: 0o600 });
+    fs.renameSync(temp, file);
+  } finally {
+    fs.rmSync(temp, { force: true });
   }
-  return { url: RELEASE_BASE + pin.asset, sha256: pin.sha256 };
 }
 
 export function getDataDir(env = process.env) {
@@ -41,7 +71,8 @@ export function computeFileHash(filePath) {
 export async function installBackend(options = {}) {
   const platform = options.platform || process.platform;
   const arch = options.arch || process.arch;
-  const pin = options.expectedHash && options.url ? null : pinnedBinary(platform, arch);
+  const channel = options.channel ?? 'optimized';
+  const pin = options.expectedHash && options.url ? null : pinnedBinary(platform, arch, channel);
   const expectedHash = options.expectedHash || pin.sha256;
   const downloadUrl = options.url || pin.url;
   const fetchFn = options.fetchFn || globalThis.fetch;
@@ -62,8 +93,6 @@ export async function installBackend(options = {}) {
     if (existingHash === expectedHash) {
       binaryReady = true;
       console.log(`Backend binary verified: ${binPath}`);
-    } else {
-      fs.unlinkSync(binPath);
     }
   }
 
@@ -97,7 +126,11 @@ export async function installBackend(options = {}) {
     }
   }
 
-  return { binPath, ...ensureDataFiles(dataDir) };
+  const files = ensureDataFiles(dataDir);
+  // A local custom build keeps the user's channel. Official installs record their
+  // selection only after verification and replacement succeeded.
+  if ((!options.expectedHash && !options.url) || options.channel !== undefined) saveBackendChannel(dataDir, channel);
+  return { binPath, ...files };
 }
 
 // ensureDataFiles creates config.json and secrets.json when missing; existing ones are kept.
@@ -136,7 +169,7 @@ function ensureDataFiles(dataDir) {
 
 export function startBackend(options = {}) {
   const dataDir = options.dataDir || getDataDir();
-  const expectedHash = options.expectedHash || pinnedBinary().sha256;
+  const expectedHash = options.expectedHash || pinnedBinary(process.platform, process.arch, backendChannel(dataDir)).sha256;
   const spawnFn = options.spawnFn || spawn;
   const { binPath, args, env } = prepareLaunch(dataDir, [expectedHash]);
 
@@ -236,12 +269,11 @@ function prepareLaunch(dataDir, trustedHashes, platform = process.platform) {
   return { binPath, args, env, port: config.port, secrets };
 }
 
-// trustedHashes is what a backend binary in dataDir may hash to: the pinned upstream build for
-// this platform, plus a local Argon build installed by `backend:install:argon`.
+// trustedHashes accepts the selected release channel and any explicitly installed local build.
 function trustedHashes(dataDir, platform, arch) {
   const hashes = [];
   try {
-    hashes.push(pinnedBinary(platform, arch).sha256);
+    hashes.push(pinnedBinary(platform, arch, backendChannel(dataDir)).sha256);
   } catch {}
   try {
     const argon = JSON.parse(fs.readFileSync(path.join(dataDir, 'argon-build.json'), 'utf8'));
@@ -318,7 +350,7 @@ async function withLock(dataDir, fn, timeoutMs) {
 
 // ensureBackend makes sure the local backend is installed and running, and returns how to reach
 // it. A backend already answering with this setup's key is left alone. Otherwise a missing or
-// untrusted binary is (re)installed from the pinned upstream release, config and secrets are
+// untrusted binary is (re)installed from the selected release channel, config and secrets are
 // created when missing, and the backend is started in the background (logging to backend.log)
 // so it outlives the caller.
 export async function ensureBackend(options = {}) {
@@ -344,7 +376,7 @@ export async function ensureBackend(options = {}) {
     const trusted = trustedHashes(dataDir, platform, arch);
     const binPath = binaryPath(dataDir, platform);
     if (!fs.existsSync(binPath) || !trusted.includes(computeFileHash(binPath))) {
-      await installBackend({ dataDir, platform, arch, fetchFn });
+      await installBackend({ dataDir, platform, arch, fetchFn, channel: backendChannel(dataDir) });
     } else {
       ensureDataFiles(dataDir);
     }

package/native-task/README.md

@@ -29,7 +29,9 @@
 
 2026-10-15：已执行通过 41 项 Python 测试和 12 项 Node 测试；真实 Magpie `0.1.1244` 的隔离环境完成了插件安装、本地连接、模型发现及 8 个 HTTP 请求的工具往返测试。该网关测试使用模拟原生上游，包含两次串行工具、最终答案重试、错误会话/调用 ID 拒绝、旧工具阶段拒绝和下一轮用户消息。
 
-当前实现已使用现有登录完成 OAuth 续期及保存轮次读取，但真实 Task 请求被 Google 返回的 `Remy quota exhausted`（gRPC 8）拒绝，尚未完成本版真实 Argon 工具端到端验收。服务将该错误映射为 `native_quota_exhausted`，不会自动重发 Task。
+2026-10-15：通过 `magpie-gemini-web` 0.4.0 的 Task 登录方式（直接加载插件，未经 Magpie 网关）完成了一次真实 Argon 工具往返：模型返回 `Read` 工具调用（19.2 秒），回传工具结果后得到正确的最终答案（13.7 秒）。此前真实 Task 请求曾被 Google 以 `Remy quota exhausted`（gRPC 8）拒绝，服务将该错误映射为 `native_quota_exhausted`，不会自动重发 Task。
+
+已知问题：客户端收到工具调用后若不回传结果（例如 agent 中途被打断），该 Task 会一直占用唯一的名额，直到工具等待和任务超时到期（最长约 4 分钟），期间其他请求返回 409 `concurrency_limit`。另外曾出现过一次首个健康检查超时（2 秒），未能复现。
 
 ## Magpie 插件安装与登录
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie-gemini-web",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Gemini Web provider for Magpie, backed by gemini-web2api-go",
   "type": "module",
   "main": "./index.mjs",
@@ -22,6 +22,7 @@
     "lib/",
     "scripts/backend.mjs",
     "scripts/backend-argon.mjs",
+    "scripts/backend-release.mjs",
     "patches/",
     "native-task/lib/",
     "native-task/bridge/",
@@ -32,6 +33,7 @@
     "native-task/LICENSE",
     "README.md",
     "README.en.md",
+    "docs/backend-release.md",
     "LICENSE",
     "LICENSE-UPSTREAM"
   ],
@@ -50,6 +52,8 @@
   "scripts": {
     "test": "node --test test/*.test.mjs native-task/test/*.test.mjs",
     "backend:install": "node scripts/backend.mjs install",
+    "backend:install:upstream": "node scripts/backend.mjs install-upstream",
+    "backend:release:build": "node scripts/backend-release.mjs --verify",
     "backend:start": "node scripts/backend.mjs start",
     "backend:status": "node scripts/backend.mjs status",
     "backend:build:argon": "node scripts/backend-argon.mjs build",

package/scripts/backend-release.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// Build from a clean, pinned upstream tree plus the checked-in patch. The developer's
+// backend-source working tree is never changed or included in release artifacts.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = fileURLToPath(new URL('..', import.meta.url));
+const pinPath = path.join(root, 'lib/backend-release.json');
+const release = JSON.parse(fs.readFileSync(pinPath, 'utf8'));
+const args = process.argv.slice(2);
+const writePins = args.includes('--write-pins');
+const verify = args.includes('--verify');
+const requested = args.find(arg => arg.startsWith('--target='))?.slice('--target='.length);
+for (const arg of args) {
+  if (!['--write-pins', '--verify'].includes(arg) && !arg.startsWith('--target=')) throw new Error(`Unknown argument: ${arg}`);
+}
+const platforms = {
+  'darwin-arm64': ['darwin', 'arm64'],
+  'darwin-x64': ['darwin', 'amd64'],
+  'linux-x64': ['linux', 'amd64'],
+  'linux-arm64': ['linux', 'arm64'],
+  'win32-x64': ['windows', 'amd64'],
+  'win32-arm64': ['windows', 'arm64']
+};
+const target = requested === 'host' ? `${process.platform}-${process.arch}` : requested;
+if (target && !platforms[target]) throw new Error(`Unsupported target: ${target}`);
+if (writePins && (target || verify)) throw new Error('--write-pins requires a full build without --verify');
+const targets = target ? [target] : Object.keys(platforms);
+const output = path.join(root, 'backend-build', 'release');
+fs.mkdirSync(output, { recursive: true });
+const scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'magpie-backend-build-'));
+const source = path.join(scratch, 'source');
+fs.mkdirSync(source);
+const env = { ...process.env, CGO_ENABLED: '0', GOFLAGS: '', GOEXPERIMENT: '',
+  GOTOOLCHAIN: `go${release.goVersion}`, GOAMD64: 'v1', GOARM64: 'v8.0' };
+for (const name of ['ARGON_PROBE_COOKIE', 'GW2A_UPLOAD_PROBE', 'SQL_DSN', 'GOOS', 'GOARCH']) delete env[name];
+const go = (argv, extraEnv = {}) => execFileSync('go', argv, { cwd: source, env: { ...env, ...extraEnv }, stdio: 'inherit' });
+const hash = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
+const patchPath = path.join(root, 'patches/argon.patch');
+const flags = ['-trimpath', '-buildvcs=false', '-ldflags=-s -w'];
+
+try {
+  let upstream = path.join(root, 'backend-source');
+  try {
+    execFileSync('git', ['-C', upstream, 'cat-file', '-e', `${release.upstream.commit}^{commit}`], { stdio: 'pipe' });
+  } catch {
+    upstream = path.join(scratch, 'upstream');
+    execFileSync('git', ['init', '-q', upstream]);
+    execFileSync('git', ['-C', upstream, 'fetch', '--depth=1', release.upstream.repository, release.upstream.commit], { stdio: 'inherit' });
+  }
+  const archive = path.join(scratch, 'upstream.tar');
+  execFileSync('git', ['-C', upstream, 'archive', '--format=tar', `--output=${archive}`, release.upstream.commit]);
+  // Relative archive paths also work with Git for Windows' tar, which otherwise
+  // treats the drive letter in C:\\... as a remote archive host.
+  execFileSync('tar', ['-xf', 'upstream.tar', '-C', 'source'], { cwd: scratch });
+  execFileSync('git', ['apply', '--check', patchPath], { cwd: source, stdio: 'inherit' });
+  execFileSync('git', ['apply', patchPath], { cwd: source, stdio: 'inherit' });
+  const versionPath = path.join(source, 'internal/app/server.go');
+  const server = fs.readFileSync(versionPath, 'utf8');
+  const versionLine = /^const Version = "[^"]+"$/m;
+  if (!versionLine.test(server)) throw new Error('Backend version declaration not found');
+  fs.writeFileSync(versionPath, server.replace(versionLine, `const Version = ${JSON.stringify(release.version)}`));
+  console.log(`Testing ${release.version} from ${release.upstream.commit} with patches/argon.patch`);
+  go(['version']);
+  go(['test', './...', '-count=1']);
+
+  const binaries = {};
+  for (const key of targets) {
+    const [goos, goarch] = platforms[key];
+    const asset = `gemini-web2api-go_v${release.version}_${goos}_${goarch}${goos === 'windows' ? '.exe' : ''}`;
+    const file = path.join(output, asset);
+    console.log(`Building ${key}: ${asset}`);
+    go(['build', ...flags, '-o', file, '.'], { GOOS: goos, GOARCH: goarch });
+    const bytes = fs.readFileSync(file);
+    const sha256 = hash(bytes);
+    if (verify && (release.binaries[key]?.sha256 !== sha256 || release.binaries[key]?.asset !== asset)) {
+      throw new Error(`Release pin mismatch for ${key}: built ${sha256}`);
+    }
+    binaries[key] = { asset, sha256 };
+    if (key === `${process.platform}-${process.arch}`) {
+      const version = execFileSync(file, ['--version'], { encoding: 'utf8' }).trim();
+      if (version !== `gemini-web2api-go ${release.version}`) throw new Error(`Unexpected binary version: ${version}`);
+      console.log(version);
+    }
+  }
+
+  if (!target) {
+    const sourceName = `gemini-web2api-go_v${release.version}_source.tar.gz`;
+    const sourceArchive = fs.openSync(path.join(output, sourceName), 'w');
+    try {
+      execFileSync('tar', ['-czf', '-', '.'], { cwd: source, stdio: ['ignore', sourceArchive, 'inherit'] });
+    } finally {
+      fs.closeSync(sourceArchive);
+    }
+    fs.copyFileSync(path.join(root, 'LICENSE-UPSTREAM'), path.join(output, 'LICENSE-UPSTREAM'));
+    const build = { version: release.version, upstream: release.upstream, goVersion: release.goVersion,
+      patch: 'patches/argon.patch', patchSha256: hash(fs.readFileSync(patchPath)),
+      versionOverride: release.version, cgoEnabled: false, flags, binaries };
+    fs.writeFileSync(path.join(output, 'build.json'), `${JSON.stringify(build, null, 2)}\n`);
+    const assets = [...Object.values(binaries).map(b => b.asset), sourceName, 'LICENSE-UPSTREAM', 'build.json'].sort();
+    fs.writeFileSync(path.join(output, 'SHA256SUMS.txt'), assets.map(name => `${hash(fs.readFileSync(path.join(output, name)))}  ${name}\n`).join(''));
+    if (writePins) fs.writeFileSync(pinPath, `${JSON.stringify({ ...release, binaries }, null, 2)}\n`);
+  }
+  console.log(`Release artifacts ready: ${output}`);
+} finally {
+  fs.rmSync(scratch, { recursive: true, force: true });
+}

package/scripts/backend.mjs

@@ -8,6 +8,9 @@ async function main() {
     case 'install':
       await installBackend();
       break;
+    case 'install-upstream':
+      await installBackend({ channel: 'upstream' });
+      break;
     case 'start':
       startBackend();
       break;
@@ -15,7 +18,7 @@ async function main() {
       await statusBackend();
       break;
     default:
-      console.error('Usage: node scripts/backend.mjs <install|start|status>');
+      console.error('Usage: node scripts/backend.mjs <install|install-upstream|start|status>');
       process.exit(1);
   }
 }