magpie-gemini-web 0.5.4 → 0.5.5

package/README.en.md

@@ -29,7 +29,7 @@ Install **magpie-gemini-web** from the Magpie plugin market, then sign in to eit
 
 1. Sign in to **Google AI Studio** in Magpie and choose **「用 Google 账号登录（推荐）」** (Sign in with a Google account).
 2. Sign in to your Google account in the separate login window that opens (your regular browser is unaffected), then close the window.
-   > On first run, the login browser Camoufox (~300 MB) is downloaded first, so the window may take a few minutes to appear. Complete sign-in within 15 minutes.
+   > On first run, the local service (~25 MB) and the login browser Camoufox (~300 MB) are downloaded first, so the window may take a few minutes to appear. While they download, Magpie opens a progress page in your browser. Magpie waits at most 10 minutes, downloads included, so finish signing in promptly; if GitHub is unreachable, set `studio.proxy` first (see plugin options and proxy settings below).
 3. **Managing accounts:** Choose "Sign in with a Google account" again at any time to **add a new account**, create a card for an existing local account, or **re-authenticate** an expired account.
 
 ### Option 2: Gemini Web (`gemini-web`)
@@ -74,6 +74,10 @@ magpie plugin options magpie-gemini-web '{"allowImages":true}'
 magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:7890"}}'
 ```
 
+> **Windows PowerShell**: `magpie` runs the `magpie.cmd` wrapper, which loses the double quotes inside the JSON when it passes the arguments on. Call the program behind it directly instead: it is in the same folder as `magpie.cmd` (which `where.exe magpie` finds), named something like `magpie-windows-amd64.exe`, and Magpie's Settings > Command line shows it too. How to write it depends on the PowerShell version (`$PSVersionTable.PSVersion` shows it):
+> - PowerShell 7.3 or later, default settings: `& "<full path to the program>" plugin options magpie-gemini-web '{"allowImages":true}'`
+> - Windows PowerShell 5.1 (built into Windows): it doesn't escape the double quotes in an argument for you, so write them as `\"`: `& "<full path to the program>" plugin options magpie-gemini-web '{\"allowImages\":true}'`
+
 | Option | Default | Scope | Description |
 | :--- | :--- | :--- | :--- |
 | `allowTools` | `true` | Shared (override via `studio.allowTools`) | Allow tool calls. When `false`, requests with tools return 400 |
@@ -89,8 +93,8 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 **Using a proxy to reach Google:**
 - **AI Studio:** Preferably set it in the local admin page. Open the address on the usage card's "管理页" (admin page) line (default `http://127.0.0.1:2048`) and sign in as `magpie` with `adminPassword` from `config.json` in the data directory. Save the proxy, then restart the service from the admin page. The plugin keeps the saved value when it restarts the backend.
   - Alternatively, `studio.proxy` or `AI_STUDIO_PROXY` take precedence over the saved proxy. A change applies after the local service restarts (`npm run studio:stop`; the next request starts it again).
-  - With neither set, the backend falls back to the `HTTPS_PROXY` environment variable or the system proxy (Windows proxy settings).
-  - **The provider proxy set for `ai-studio` in Magpie is not passed to the local backend**; use one of the options above.
+  - With none set, the backend goes out directly, or on Windows through the system proxy (Windows proxy settings).
+  - **The backend uses neither Magpie's proxies (including the provider proxy set for `ai-studio`) nor `HTTPS_PROXY` and similar variables**: it keeps running after Magpie quits, when a proxy borrowed from Magpie may be gone. Use one of the options above. A backend started by a plugin version from before this fix may still be using a proxy from the environment it was started in (Magpie's, for example); the "代理出口" line marks it and says what a restart changes.
   - The usage card's "代理出口" (proxy) line, the Google sign-in instructions and failure messages, and `npm run studio:status` show the proxy the backend actually uses, where it comes from, and whether a new setting still needs a restart.
   - The listen address, API key and admin credentials are managed by the plugin; changing them in the admin page has no effect.
 - **Gemini Web:** The backend ignores `HTTP_PROXY`. Add your proxy to the proxy pool in the local admin panel at `http://127.0.0.1:8083/admin` (password is `adminToken` in `secrets.json` inside the data directory).
@@ -109,6 +113,11 @@ After upgrading the plugin, run `magpie provider models gemini-web` to refresh a
 
 <br>
 
+**When the local service starts and stops:**
+- It starts in the background when the plugin loads (when Magpie opens, for example); after that, a request or a usage card refresh starts it again if it isn't running.
+- It is a process of its own: **quitting Magpie doesn't stop it**, and Magpie picks it up again the next time it opens.
+- To stop it, use `studio:stop` below (or the full command the card or an error gives). A stop lasts until the next request, which starts it again.
+
 When a plugin error asks you to run a command, it includes the full ready-to-copy path. From the plugin directory, you can also run:
 
 | Command | Description |

package/README.md

@@ -29,7 +29,7 @@
 
 1. 在 Magpie 中登录 **Google AI Studio**，选择 **「用 Google 账号登录（推荐）」**。
 2. 在弹出的独立登录窗口中登录 Google 账号（不影响日常浏览器），完成后直接关闭窗口。
-   > 首次使用会自动下载登录浏览器 Camoufox（约 300 MB），弹窗可能需要等几分钟才出现；请在 15 分钟内完成登录。
+   > 首次使用要先下载本地服务（约 25 MB）和登录浏览器 Camoufox（约 300 MB），弹窗可能需要等几分钟才出现。需要下载时，Magpie 会在浏览器里打开一个进度页，显示下载进度。Magpie 最多等 10 分钟（下载的时间也算在内），请尽快完成登录；连不上 GitHub 时，先按下面「插件选项与代理配置」设置 `studio.proxy`。
 3. **后续管理**：再次点击「用 Google 账号登录」，可选择**添加新账号**、为本机已有账号建卡，或为过期账号**重新登录**。
 
 ### 方式二：Gemini Web (`gemini-web`)
@@ -74,6 +74,10 @@ magpie plugin options magpie-gemini-web '{"allowImages":true}'
 magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:7890"}}'
 ```
 
+> **Windows PowerShell**：`magpie` 实际运行的是 `magpie.cmd` 包装器，它转发参数时会弄丢 JSON 里的双引号。请直接调用它背后的可执行文件：这个文件和 `magpie.cmd` 在同一个文件夹（`where.exe magpie` 可以找到），文件名可能是 `magpie-windows-amd64.exe` 之类，Magpie 的「设置 → 命令行」里也会显示。写法取决于 PowerShell 版本（用 `$PSVersionTable.PSVersion` 查看）：
+> - PowerShell 7.3 及以上，默认设置：`& "<可执行文件的完整路径>" plugin options magpie-gemini-web '{"allowImages":true}'`
+> - Windows PowerShell 5.1（系统自带）：它不会替你转义参数里的双引号，要写成 `\"`：`& "<可执行文件的完整路径>" plugin options magpie-gemini-web '{\"allowImages\":true}'`
+
 | 选项 | 默认值 | 适用范围 | 说明 |
 | :--- | :--- | :--- | :--- |
 | `allowTools` | `true` | 共用（可用 `studio.allowTools` 单独覆盖） | 允许工具调用。设为 `false` 时带工具的请求返回 400 |
@@ -89,8 +93,8 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 **配置代理访问 Google：**
 - **AI Studio**：推荐在本地管理页设置。打开额度卡片「管理页」一行里的地址（默认 `http://127.0.0.1:2048`），用户名 `magpie`，密码是数据目录 `config.json` 里的 `adminPassword`；保存代理后在管理页重启服务即可生效，之后插件重启后端也不会覆盖它。
   - 也可以用上表的 `studio.proxy` 或环境变量 `AI_STUDIO_PROXY`，它们优先于管理页里保存的代理。改了要重启本地服务才生效（`npm run studio:stop`，下一次请求会自动启动）。
-  - 都没设置时，后端自动使用 `HTTPS_PROXY` 环境变量或系统代理（Windows 的「代理」设置）。
-  - **Magpie 里给 `ai-studio` 设置的供应商代理不会传给本地后端**，请用上面两种方式之一设置。
+  - 都没设置时，后端直连；Windows 上会使用系统代理（Windows 的「代理」设置）。
+  - **后端不使用 Magpie 的代理（包括给 `ai-studio` 设置的供应商代理），也不读取 `HTTPS_PROXY` 等环境变量**：它在 Magpie 退出后仍会运行，借用 Magpie 的代理到时可能已经失效。请用上面两种方式之一设置。加入这项修复之前的插件版本启动的后端，可能还在用启动时环境变量里的代理（比如 Magpie 的）；「代理出口」一行会标出来，并说明重启后会怎样。
   - 额度卡片的「代理出口」一行会显示后端当前实际使用的代理、它来自哪里，以及新设置是否还要重启才生效；登录 Google 时的说明、登录失败的提示和 `npm run studio:status` 也会显示。
   - 监听地址、API Key、管理员账号等由插件管理，在管理页修改不会生效。
 - **Gemini Web**：后端不读取 `HTTP_PROXY`，请打开本地管理面板 `http://127.0.0.1:8083/admin` 在代理池中添加（登录口令为数据目录 `secrets.json` 中的 `adminToken`）。
@@ -109,6 +113,11 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 
 <br>
 
+**本地服务什么时候启动、停止：**
+- 插件加载时（例如打开 Magpie）会在后台启动本地服务；之后发请求、刷新额度卡片时，服务没在运行也会自动启动。
+- 本地服务是独立进程，**退出 Magpie 不会停止它**，下次打开 Magpie 直接接着用。
+- 停止服务用下表的 `studio:stop`（或卡片、报错里给出的完整命令）。停止只是一次性的：下一次请求会再次启动它。
+
 当插件报错提示运行命令时，直接复制报错中的完整命令执行即可。在插件目录下也可使用：
 
 | 命令 | 作用 |

package/docs/studio-release.md

@@ -1,6 +1,6 @@
 # AI Studio 托管后端构建
 
-插件使用 `0.2.14-magpie.1`，基于 AIStudio2API `v0.2.14` 的固定 commit。上游版本、commit、Go 工具链、安装包及二进制 SHA-256 均记录在 `lib/studio-release.json`。MIT 许可见 `LICENSE-AISTUDIO`。
+插件使用 `0.2.14-magpie.1`，基于 AIStudio2API `v0.2.14` 的固定 commit。上游版本、commit、Go 工具链、安装包及二进制 SHA-256 均记录在 `lib/studio-release.json`。`upstream.camoufox` 是这个 commit 要求的 Camoufox 版本（上游 `internal/camoufoxnative/download.go` 里的 `camoufoxRelease`），插件靠它判断登录时要不要重新下载 Camoufox；更新上游 commit 时要一起改，构建脚本发现不一致会报错。MIT 许可见 `LICENSE-AISTUDIO`。
 
 ## 在线更新策略
 

package/lib/studio-native.mjs

@@ -5,8 +5,13 @@ import crypto from 'node:crypto';
 import net from 'node:net';
 import { fileURLToPath } from 'node:url';
 import { spawn, execFile, execFileSync } from 'node:child_process';
+import { promisify } from 'node:util';
 import release from './studio-release.json' with { type: 'json' };
 
+// execFileAsync is execFile awaited: unpacking a download this way leaves the plugin host free to answer
+// meanwhile, a sign-in's progress page among others.
+const execFileAsync = promisify(execFile);
+
 export const STUDIO_VERSION = `v${release.version}`;
 export const PINNED_ARCHIVES = release.binaries;
 // The port a new setup tries first: AIStudio2API's own default.
@@ -17,6 +22,16 @@ const LOG_ROTATE_BYTES = 10 * 1024 * 1024;
 const adminSessions = new Map();
 const inFlightStarts = new Map();
 const inFlightReady = new Map();
+// setupSteps is where a start of the service stands, by data dir, while one is in flight:
+// { step: 'download', received, total } (bytes; total 0 while unknown), { step: 'install' } or
+// { step: 'start' }. A sign-in's progress page reads it (setupStep).
+const setupSteps = new Map();
+
+// setupStep is where the start of the service in dataDir stands, null when none is in flight or
+// it hasn't got to a step yet (as while it waits for another's lock).
+export function setupStep(dataDir) {
+  return setupSteps.get(dataDir) ?? null;
+}
 
 export function studioDataDir(env = process.env) {
   return env.AI_STUDIO_DATA_DIR || path.join(os.homedir(), '.local', 'share', 'magpie-ai-studio');
@@ -122,7 +137,7 @@ export function pluginProxy(explicit) {
 
 // downloadProxy is the proxy an install downloads through: the one given (an empty one turns it
 // off), else AI_STUDIO_PROXY, else the service's saved one, else the one an older config.json kept.
-function downloadProxy(dataDir, explicit, savedConfig) {
+export function downloadProxy(dataDir, explicit, savedConfig) {
   if (explicit !== undefined) return validateProxy(explicit);
   if (process.env.AI_STUDIO_PROXY !== undefined) return validateProxy(process.env.AI_STUDIO_PROXY);
   let saved;
@@ -181,6 +196,9 @@ const ENV_KEYS = [
   'BUILD_NATIVE_NONSTREAM', 'MODEL_CHANNELS', 'MEDIA_OUTPUT', 'MEDIA_BASE_URL'
 ];
 
+// PROXY_ENV are the proxy variables the service would fall back to with no PROXY of its own.
+const PROXY_ENV = ['HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY'];
+
 // SETTING_DEFAULTS are the settings the admin page owns, as a new setup has them. They are written
 // to .env when it lacks them and left as the admin page saves them after that.
 const SETTING_DEFAULTS = {
@@ -550,7 +568,8 @@ export const PROXY_SOURCES = {
   saved: '管理页',
   startup: '服务启动时的设置',
   unknown: '来源待确认',
-  system: '自动检测：HTTPS_PROXY 环境变量或系统代理',
+  system: '自动检测：系统代理设置',
+  legacy: '旧版插件启动的服务自动检测到的，可能来自启动时的环境变量或系统代理设置',
   direct: '直连'
 };
 
@@ -570,10 +589,13 @@ export function redactProxy(value) {
 // LAUNCH_RECORD says, for the service process this plugin last started, whether it was started
 // with a PROXY of the plugin's over the saved one, and whose: 'option' or 'env' (see pluginProxy),
 // null for none. A caller that doesn't know the plugin's options (the CLI) reads it from there.
+// proxyEnv 'none' says it was started with no *_PROXY in its environment (see launchStudio); a
+// record without it is an older plugin's, whose service may have had one: Magpie's, a shell's,
+// or none, which nothing kept tells apart.
 const LAUNCH_RECORD = 'backend.launch.json';
 
 function writeLaunchRecord(dataDir, pid, proxy) {
-  const record = { pid, proxy: pluginProxy(proxy)?.source ?? null };
+  const record = { pid, proxy: pluginProxy(proxy)?.source ?? null, proxyEnv: 'none' };
   try {
     fs.writeFileSync(path.join(dataDir, LAUNCH_RECORD), JSON.stringify(record) + '\n', { mode: 0o600 });
   } catch {}
@@ -637,8 +659,12 @@ export async function studioProxy(local, options = {}) {
   if (!active) source = 'direct';
   else if (unsure) source = 'unknown';
   else if (pending) source = 'startup';
-  else if (!loaded) source = 'system';
-  else source = wantedSource;
+  else if (!loaded) {
+    // An older plugin started it, maybe with a proxy in its environment, which the system's can't
+    // be told from
+    const record = launchRecord(local.dataDir);
+    source = record && record.proxyEnv !== 'none' ? 'legacy' : 'system';
+  } else source = wantedSource;
 
   return {
     active: redactProxy(active),
@@ -738,6 +764,102 @@ export async function checkStudioHealth(local, fetchFn) {
   return { state: 'up', status };
 }
 
+// CAMOUFOX_EXECUTABLES are where upstream's Camoufox, the browser it signs Google accounts in
+// with, has its executable in its folder, by platform (camoufoxnative.camoufoxExecutablePath).
+const CAMOUFOX_EXECUTABLES = {
+  win32: 'camoufox.exe',
+  linux: 'camoufox-bin',
+  darwin: path.join('Camoufox.app', 'Contents', 'MacOS', 'camoufox')
+};
+// How much of the end of backend.log camoufoxState reads for the download's size
+const LOG_TAIL_BYTES = 256 * 1024;
+// CAMOUFOX_VERSION is the Camoufox the pinned upstream takes (camoufoxnative.camoufoxRelease): it
+// downloads that one over any other it finds.
+export const CAMOUFOX_VERSION = release.upstream.camoufox;
+
+// camoufoxState says whether the service in dataDir has Camoufox, which it downloads (from GitHub,
+// some 300 MB) when an account first signs in and whenever the one it has isn't CAMOUFOX_VERSION:
+// { ready: true }, or how far that download has got, as upstream's camoufoxnative leaves it in
+// runtime/ under the service's working directory (dataDir): the bytes received of the archive's
+// total (0 while not known), and whether it is unpacking. One named by CAMOUFOX_PATH is the only
+// one upstream takes, and never downloads over.
+export function camoufoxState(dataDir, platform = process.platform, env = process.env) {
+  const exe = CAMOUFOX_EXECUTABLES[platform];
+  if (!exe || env.CAMOUFOX_PATH?.trim()) return { ready: true };
+  const runtime = path.join(dataDir, 'runtime');
+  const candidates = [path.join(runtime, 'camoufox', exe), path.join(dataDir, 'package', 'runtime', 'camoufox', exe)];
+  if (platform === 'win32' && env.LOCALAPPDATA) candidates.push(path.join(env.LOCALAPPDATA, 'camoufox', 'camoufox', 'Cache', exe));
+  if (candidates.some(camoufoxPinned)) return { ready: true };
+
+  let names = [];
+  try { names = fs.readdirSync(runtime); } catch {}
+  const part = names.find(n => /^camoufox-.+\.zip\.part$/.test(n));
+  let received = 0;
+  try { if (part) received = fs.statSync(path.join(runtime, part)).size; } catch {}
+  const total = camoufoxSize(path.join(dataDir, 'backend.log'));
+  return {
+    ready: false,
+    received,
+    // the log rounds the size down to a MiB
+    total: total && Math.max(total, received),
+    unpacking: names.some(n => n.startsWith('.camoufox-stage-'))
+  };
+}
+
+// camoufoxPinned says whether exe is a Camoufox upstream takes as it is: the version its
+// application.ini gives, beside it or in the app's Resources (macOS), is CAMOUFOX_VERSION
+// (camoufoxnative.validateCamoufoxExecutable).
+function camoufoxPinned(exe) {
+  try {
+    if (fs.statSync(exe).isDirectory()) return false;
+  } catch {
+    return false;
+  }
+  const dir = path.dirname(exe);
+  for (const ini of [path.join(dir, 'application.ini'), path.join(path.dirname(dir), 'Resources', 'application.ini')]) {
+    let text;
+    try {
+      text = fs.readFileSync(ini, 'utf8');
+    } catch (err) {
+      if (err.code === 'ENOENT') continue;
+      return false;
+    }
+    for (const line of text.split('\n')) {
+      const version = line.trim().match(/^Version=(.*)$/);
+      if (version) return version[1].trim() === CAMOUFOX_VERSION;
+    }
+  }
+  return false;
+}
+
+// camoufoxSize is the size of the Camoufox archive the service last began downloading, as its log
+// says it ("Camoufox 下载已开始", in whole MiB), 0 when it doesn't.
+function camoufoxSize(logPath) {
+  let tail;
+  try {
+    const fd = fs.openSync(logPath, 'r');
+    try {
+      const size = fs.fstatSync(fd).size;
+      const length = Math.min(size, LOG_TAIL_BYTES);
+      tail = Buffer.alloc(length);
+      fs.readSync(fd, tail, 0, length, size - length);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return 0;
+  }
+  const lines = tail.toString('utf8').split('\n');
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (!lines[i].includes('Camoufox 下载已开始')) continue;
+    try {
+      const mib = JSON.parse(lines[i]).size_mib;
+      if (Number.isFinite(mib) && mib > 0) return mib * 1024 * 1024;
+    } catch {}
+  }
+  return 0;
+}
+
 export async function studioStatus(options = {}) {
   const dataDir = options.dataDir || studioDataDir();
   const platform = options.platform || process.platform;
@@ -974,6 +1096,20 @@ async function withLock(dataDir, fn, timeoutMs = 600000) {
   }
 }
 
+// downloadProgress is a download's step as curl writes it: the bytes in file so far, of the
+// Content-Length the last response in headersFile gave (the archive's, after GitHub's redirects),
+// 0 while that isn't known.
+export function downloadProgress(file, headersFile) {
+  let received = 0;
+  let total = 0;
+  try { received = fs.statSync(file).size; } catch {}
+  try {
+    const lengths = [...fs.readFileSync(headersFile, 'latin1').matchAll(/^content-length:\s*(\d+)/gim)];
+    if (lengths.length) total = Number(lengths.at(-1)[1]);
+  } catch {}
+  return { step: 'download', received, total: total >= received ? total : 0 };
+}
+
 export async function installStudio(options = {}) {
   const platform = options.platform || process.platform;
   const arch = options.arch || process.arch;
@@ -1037,6 +1173,7 @@ export async function installStudio(options = {}) {
       const downloadUrl = `https://github.com/${release.repository}/releases/download/${release.tag}/${pin.asset}`;
       archivePath = path.join(stageDir, pin.asset);
       const proxy = downloadProxy(dataDir, options.proxy, savedConfig);
+      setupSteps.set(dataDir, { step: 'download', received: 0, total: 0 });
 
       if (options.fetchFn && options.fetchFn !== globalThis.fetch) {
         const res = await options.fetchFn(downloadUrl, { signal: AbortSignal.timeout(300000) });
@@ -1055,18 +1192,26 @@ export async function installStudio(options = {}) {
         if (proxy) {
           curlArgs.push('--proxy', proxy);
         }
-        curlArgs.push('-o', archivePath, downloadUrl);
-        await new Promise((resolve, reject) => {
-          execFile('curl', curlArgs, (err, _stdout, stderr) => {
-            if (err) {
-              const status = err.code || err.status || 'failed';
-              const reason = String(stderr || '').trim().slice(0, 500);
-              reject(new Error(`Failed to download AIStudio2API archive via curl (status: ${status})${reason ? `: ${reason}` : ''}`));
-            } else {
-              resolve();
-            }
+        // The headers curl dumps as they come say the archive's size, and the file it writes says
+        // how much has come: together they show the download's progress.
+        const headersPath = path.join(stageDir, 'headers.txt');
+        curlArgs.push('-D', headersPath, '-o', archivePath, downloadUrl);
+        const watch = setInterval(() => setupSteps.set(dataDir, downloadProgress(archivePath, headersPath)), 500);
+        try {
+          await new Promise((resolve, reject) => {
+            execFile('curl', curlArgs, (err, _stdout, stderr) => {
+              if (err) {
+                const status = err.code || err.status || 'failed';
+                const reason = String(stderr || '').trim().slice(0, 500);
+                reject(new Error(`Failed to download AIStudio2API archive via curl (status: ${status})${reason ? `: ${reason}` : ''}`));
+              } else {
+                resolve();
+              }
+            });
           });
-        });
+        } finally {
+          clearInterval(watch);
+        }
         const downloadedHash = computeFileHash(archivePath);
         if (downloadedHash !== expectedHash) {
           throw new Error(`SHA256 checksum mismatch for downloaded archive: expected ${expectedHash}, got ${downloadedHash}`);
@@ -1079,11 +1224,12 @@ export async function installStudio(options = {}) {
       fs.chmodSync(retainedArchive, 0o600);
     }
 
+    setupSteps.set(dataDir, { step: 'install' });
     const extractDir = path.join(stageDir, 'extracted');
     fs.mkdirSync(extractDir, { recursive: true, mode: 0o700 });
 
     if (platform === 'win32') {
-      execFileSync('powershell', [
+      await execFileAsync('powershell', [
         '-NoProfile',
         '-NonInteractive',
         '-Command',
@@ -1093,7 +1239,7 @@ export async function installStudio(options = {}) {
         windowsHide: true
       });
     } else {
-      const listOutput = execFileSync('tar', ['-tvf', archivePath], { encoding: 'utf8' }).split('\n').filter(Boolean);
+      const listOutput = (await execFileAsync('tar', ['-tvf', archivePath], { encoding: 'utf8' })).stdout.split('\n').filter(Boolean);
       for (const line of listOutput) {
         const parts = line.split(/\s+/);
         const mode = parts[0];
@@ -1101,14 +1247,14 @@ export async function installStudio(options = {}) {
           throw new Error(`Symlinks or special files in archive rejected: ${line}`);
         }
       }
-      const listing = execFileSync('tar', ['-tf', archivePath], { encoding: 'utf8' }).split('\n').filter(Boolean);
+      const listing = (await execFileAsync('tar', ['-tf', archivePath], { encoding: 'utf8' })).stdout.split('\n').filter(Boolean);
       for (const entry of listing) {
         const entryParts = entry.replace(/\\/g, '/').split('/');
         if (entryParts.includes('..') || entry.startsWith('/') || entry.startsWith('\\') || /^[a-zA-Z]:/.test(entry)) {
           throw new Error(`Dangerous member in archive rejected: ${entry}`);
         }
       }
-      execFileSync('tar', ['-xzf', archivePath, '-C', extractDir]);
+      await execFileAsync('tar', ['-xzf', archivePath, '-C', extractDir]);
     }
 
     let topDir = extractDir;
@@ -1279,7 +1425,8 @@ function shared(map, key, fn) {
 // it to take requests; a managementOnly caller doesn't wait for the latter.
 export async function ensureStudio(options = {}) {
   const dataDir = options.dataDir || studioDataDir();
-  const { local, status } = await shared(inFlightStarts, dataDir, () => launchStudio({ ...options, dataDir }));
+  const { local, status } = await shared(inFlightStarts, dataDir,
+    () => launchStudio({ ...options, dataDir }).finally(() => setupSteps.delete(dataDir)));
   if (options.managementOnly) return local;
   return shared(inFlightReady, dataDir, () => readyStudio(local, status, options));
 }
@@ -1372,12 +1519,17 @@ async function launchStudio(options) {
     // would hide the ones saved in .env
     const cleanEnv = {};
     for (const [k, v] of Object.entries(process.env)) {
-      if (!k.startsWith('AISTUDIO_') && !k.startsWith('WAA_') && !ENV_KEYS.includes(k.toUpperCase())) {
+      if (!k.startsWith('AISTUDIO_') && !k.startsWith('WAA_') && !ENV_KEYS.includes(k.toUpperCase()) && !PROXY_ENV.includes(k.toUpperCase())) {
         cleanEnv[k] = v;
       }
     }
+    // Nor a proxy of the starter's: the service outlives Magpie, whose plugin host gives a program it
+    // starts with none of these the proxy of the request it starts in, or Magpie's own, which may be
+    // gone by the time the service uses it. Empty ones keep the host from adding its own.
+    for (const k of PROXY_ENV) cleanEnv[k] = '';
     Object.assign(cleanEnv, serviceEnv(dataDir, config, { proxy: options.proxy }));
 
+    setupSteps.set(dataDir, { step: 'start' });
     const logPath = path.join(dataDir, 'backend.log');
     rotateLog(logPath);
     const logFd = fs.openSync(logPath, 'a', 0o600);

package/lib/studio-page.mjs

@@ -0,0 +1,173 @@
+import http from 'node:http';
+import crypto from 'node:crypto';
+
+// A page closes this long after it opened even when nothing closes it: longer than a sign-in can
+// take (a download, the service's start, the login's 15 minutes).
+const PAGE_LIFETIME_MS = 40 * 60 * 1000;
+
+// openProgressPage serves a sign-in's progress as a page of its own on 127.0.0.1, at a path no
+// other page can guess. read() is what it shows, which it asks for every second:
+//   { title, note, steps: [{ label, state, detail, received, total }], done, error }
+// with state 'pending', 'active', 'done' or 'failed', and received and total in bytes (total 0
+// while not known) for a step that downloads. It stops at close(), or at PAGE_LIFETIME_MS.
+export async function openProgressPage(read) {
+  const token = crypto.randomBytes(16).toString('hex');
+  const nonce = crypto.randomBytes(16).toString('base64');
+  let host = '';
+  const server = http.createServer((req, res) => {
+    const headers = { 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff', 'Referrer-Policy': 'no-referrer' };
+    // the Host a rebound DNS name sends can't reach it either
+    if (req.method !== 'GET' || req.headers.host !== host) {
+      res.writeHead(404, headers).end();
+      return;
+    }
+    if (req.url === `/${token}`) {
+      res.writeHead(200, {
+        ...headers,
+        'Content-Type': 'text/html; charset=utf-8',
+        'Content-Security-Policy': `default-src 'none'; style-src 'unsafe-inline'; script-src 'nonce-${nonce}'; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'`
+      }).end(PAGE.replace('NONCE', nonce));
+      return;
+    }
+    if (req.url === `/${token}/status`) {
+      let body;
+      try {
+        body = JSON.stringify(read());
+      } catch (err) {
+        res.writeHead(500, { ...headers, 'Content-Type': 'application/json' }).end(JSON.stringify({ error: err.message }));
+        return;
+      }
+      res.writeHead(200, { ...headers, 'Content-Type': 'application/json' }).end(body);
+      return;
+    }
+    res.writeHead(404, headers).end();
+  });
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  server.unref();
+  host = `127.0.0.1:${server.address().port}`;
+  const timer = setTimeout(close, PAGE_LIFETIME_MS);
+  timer.unref();
+  function close() {
+    clearTimeout(timer);
+    server.close();
+    server.closeAllConnections?.();
+  }
+  return { url: `http://${host}/${token}`, close };
+}
+
+// PAGE draws what the status says, as text only (nothing in it is read as HTML).
+const PAGE = `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Google AI Studio 登录进度</title>
+<style>
+:root { color-scheme: light dark; --fg: #1f2328; --muted: #656d76; --line: #d0d7de; --bar: #2f6feb; --ok: #1a7f37; --bad: #cf222e; --bg: #fff; }
+@media (prefers-color-scheme: dark) { :root { --fg: #e6edf3; --muted: #8d96a0; --line: #30363d; --bar: #4c8dff; --ok: #3fb950; --bad: #f85149; --bg: #0d1117; } }
+body { font: 15px/1.6 system-ui, -apple-system, "Segoe UI", "Microsoft YaHei", sans-serif; color: var(--fg); background: var(--bg); max-width: 640px; margin: 48px auto; padding: 0 20px; }
+h1 { font-size: 20px; margin: 0 0 4px; }
+.note { color: var(--muted); margin: 0 0 24px; }
+ol { list-style: none; padding: 0; margin: 0; }
+li { border: 1px solid var(--line); border-radius: 8px; padding: 12px 16px; margin-bottom: 12px; }
+li.pending { opacity: .55; }
+li.failed { border-color: var(--bad); }
+.head { display: flex; gap: 10px; align-items: center; font-weight: 600; }
+.mark { width: 20px; flex: none; text-align: center; }
+li.done .mark { color: var(--ok); }
+li.failed .mark { color: var(--bad); }
+.spin { display: inline-block; width: 12px; height: 12px; border: 2px solid var(--bar); border-right-color: transparent; border-radius: 50%; animation: turn .8s linear infinite; }
+@keyframes turn { to { transform: rotate(360deg); } }
+.detail { color: var(--muted); font-size: 13px; margin: 4px 0 0 30px; white-space: pre-wrap; }
+.track { height: 8px; border-radius: 4px; background: var(--line); margin: 8px 0 0 30px; overflow: hidden; }
+.fill { height: 100%; background: var(--bar); transition: width .4s; }
+.track.unknown .fill { width: 30%; animation: slide 1.2s linear infinite; }
+@keyframes slide { from { margin-left: -30%; } to { margin-left: 100%; } }
+.end { margin-top: 20px; font-weight: 600; white-space: pre-wrap; }
+.end.ok { color: var(--ok); }
+.end.bad { color: var(--bad); }
+</style>
+</head>
+<body>
+<h1 id="title">Google AI Studio 登录进度</h1>
+<p class="note" id="note"></p>
+<ol id="steps"></ol>
+<p class="end" id="end"></p>
+<script nonce="NONCE">
+const STATUS = location.pathname + '/status';
+const MARKS = { pending: '○', done: '✓', failed: '✕' };
+const mb = n => (n / 1048576).toFixed(1);
+
+function el(tag, cls, text) {
+  const e = document.createElement(tag);
+  if (cls) e.className = cls;
+  if (text) e.textContent = text;
+  return e;
+}
+
+function render(s) {
+  if (s.title) document.getElementById('title').textContent = s.title;
+  document.getElementById('note').textContent = s.note || '';
+  const list = document.getElementById('steps');
+  list.replaceChildren(...(s.steps || []).map(step => {
+    const li = el('li', step.state);
+    const mark = el('span', 'mark');
+    if (step.state === 'active') mark.append(el('span', 'spin'));
+    else mark.textContent = MARKS[step.state] || '';
+    const head = el('div', 'head');
+    head.append(mark, el('span', '', step.label));
+    li.append(head);
+    let detail = step.detail || '';
+    const downloading = step.state === 'active' && typeof step.received === 'number';
+    if (downloading) {
+      const pct = step.total ? Math.min(100, Math.floor(step.received * 100 / step.total)) : 0;
+      const got = step.total ? '已下载 ' + mb(step.received) + ' / ' + mb(step.total) + ' MB（' + pct + '%）'
+        : step.received ? '已下载 ' + mb(step.received) + ' MB' : '';
+      detail = [detail, got].filter(Boolean).join('：');
+    }
+    if (detail) li.append(el('div', 'detail', detail));
+    if (downloading) {
+      const track = el('div', step.total ? 'track' : 'track unknown');
+      const fill = el('div', 'fill');
+      if (step.total) fill.style.width = Math.min(100, step.received * 100 / step.total) + '%';
+      track.append(fill);
+      li.append(track);
+    }
+    return li;
+  }));
+  const end = document.getElementById('end');
+  if (s.error) {
+    end.className = 'end bad';
+    end.textContent = s.error;
+  } else if (s.done) {
+    end.className = 'end ok';
+    end.textContent = s.doneText || '完成了，可以关掉这个页面。';
+  }
+}
+
+let misses = 0;
+async function poll() {
+  try {
+    const res = await fetch(STATUS, { cache: 'no-store' });
+    if (!res.ok) throw new Error(String(res.status));
+    const s = await res.json();
+    misses = 0;
+    render(s);
+    if (s.done || s.error) return;
+  } catch {
+    if (++misses >= 3) {
+      const end = document.getElementById('end');
+      if (!end.textContent) end.textContent = '这个页面已经停止更新，请回到 Magpie 查看结果。';
+      return;
+    }
+  }
+  setTimeout(poll, 1000);
+}
+poll();
+</script>
+</body>
+</html>
+`;

package/lib/studio-release.json

@@ -6,7 +6,8 @@
   "upstream": {
     "version": "0.2.14",
     "repository": "https://github.com/Mag1cFall/AIStudio2API.git",
-    "commit": "370a313814099b508881807effa2a9d72f2d7e66"
+    "commit": "370a313814099b508881807effa2a9d72f2d7e66",
+    "camoufox": "152.0.4-beta.29"
   },
   "binaries": {
     "darwin-arm64": {

package/lib/studio.mjs

@@ -1,6 +1,7 @@
 import { normalizeBaseURL, credentials, forward, makeOpenAIError, UNREACHABLE_HEADER } from './backend.mjs';
 import path from 'node:path';
-import { localStudio, ensureStudio, studioAdmin, studioAccounts, studioProxy, studioCommand, validateProxy, isConnectRefused, PROXY_SOURCES } from './studio-native.mjs';
+import { localStudio, ensureStudio, studioAdmin, studioAccounts, studioProxy, studioCommand, validateProxy, isConnectRefused, PROXY_SOURCES, downloadProxy, redactProxy, studioDataDir, checkStudioHealth, setupStep, camoufoxState } from './studio-native.mjs';
+import { openProgressPage } from './studio-page.mjs';
 
 export const STUDIO_ID = 'ai-studio';
 export const STUDIO_BASE = 'http://127.0.0.1:2048/v1';
@@ -11,19 +12,32 @@ const STUDIO_EXCLUDE = /(?:image|nano-banana|tts|audio|live|transcribe|robotics|
 const NON_TEXT_CAPS = ['image_route', 'speech_route', 'live_route', 'aspect_ratio', 'output_resolution', 'interactions_api', 'transcription_output'];
 const CONTROL_CHARS = /[\x00-\x1f\x7f]/;
 
-// The service opens its own login window for a new account, and waits this long for it.
-const LOGIN_TIMEOUT_MS = 15 * 60 * 1000;
+// Magpie waits 10 minutes for a sign-in once authorize returns (signInTimeout), downloads and the
+// login window included, and doesn't stop the callback when it gives up: the callback ends a
+// little before, saying so, and the service's login window closes with its request.
+const SIGN_IN_BUDGET_MS = 10 * 60 * 1000 - 20 * 1000;
+const LATE = '超过了 Magpie 等登录的 10 分钟。已经下载的部分会保留，再登录一次会接着来。';
+// How long the question which account to sign in waits for the service to start: Magpie gives
+// the question a minute, with nothing on screen. A start that takes longer (an update to
+// download) goes on behind a new account's sign-in, whose progress page shows it.
+const ASK_WAIT_MS = 15 * 1000;
 // Upstream logs in with Camoufox even when generation runs in Go, and downloads it on the first
 // login, so that one can take minutes before a window shows.
 const LOGIN_WINDOW = [
   '第一次登录要先下载登录用的浏览器 Camoufox（约 300 MB），可能要等几分钟窗口才出现，期间这里没有变化，请耐心等待。',
-  '登录窗口是独立的，不影响你平时用的浏览器；请在 15 分钟内完成登录，完成后可以关掉窗口，日常生成不需要浏览器。'
+  '登录窗口是独立的，不影响你平时用的浏览器。Magpie 最多等 10 分钟（下载的时间也算在内），请尽快在窗口里登录；完成后可以关掉窗口，日常生成不需要浏览器。'
 ];
 const LOGIN_STEPS = [
   ...LOGIN_WINDOW,
   '想加更多 Google 账号，再来一次即可，每个账号一张卡片。'
 ].join('\n');
 const RELOGIN_STEPS = LOGIN_WINDOW.join('\n');
+// Where to set a proxy when the service can't be downloaded from GitHub
+const SETUP_PROXY_HINT = '连不上 GitHub 时，请先在插件选项 studio.proxy 或环境变量 AI_STUDIO_PROXY 里设置代理，再重新登录。';
+// A sign-in's progress page (see signInProgress), as its instructions point to it
+const PAGE_LINE = '下载和登录的进度显示在刚打开的浏览器页面里；没有自动打开的话，把下面的链接复制到浏览器里打开。';
+// A progress page stays up this long after its sign-in ends, to say how it ended.
+const PAGE_LINGER_MS = 2 * 60 * 1000;
 // AdminAccount.state as the account list shows it
 const ACCOUNT_STATES = {
   ready: '可用',
@@ -465,6 +479,9 @@ export function proxyLine(proxy, local) {
     line += `；管理页保存的是 ${named(proxy.saved)}，但服务启动时的环境变量盖住了它（旧版插件启动的服务会这样）。${restart}后应按管理页设置生效；如果由 Magpie 再次启动后仍被盖住，检查插件选项 studio.proxy 和环境变量 AI_STUDIO_PROXY`;
     return line;
   }
+  if (proxy.source === 'legacy') {
+    return `${line}。如果它来自启动时的环境变量（例如 Magpie 或终端里的 HTTPS_PROXY），${restart}后就不再使用它，改按管理页设置；如果来自系统代理设置，重启后仍会使用`;
+  }
   if (proxy.pending === 'restart') {
     line += `；${PROXY_SOURCES[proxy.wantedSource]}设置的是 ${named(proxy.wanted)}，${restart}后生效`;
   } else if (proxy.pending === 'generation') {
@@ -492,6 +509,126 @@ function serviceWindows(local, proxy) {
   return windows;
 }
 
+// TooLate is a deadline passing before what was waited for (byDeadline).
+class TooLate extends Error {}
+
+// byDeadline is work, or a TooLate when deadline (ms since the epoch) passes first; the work goes
+// on behind it.
+function byDeadline(work, deadline) {
+  let timer;
+  const late = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new TooLate()), Math.max(0, deadline - Date.now()));
+  });
+  return Promise.race([work, late]).finally(() => clearTimeout(timer));
+}
+
+// failedWhy is why a sign-in failed, as its error says it: LATE once its deadline has passed (a
+// request cut off by it fails with an abort of its own).
+function failedWhy(err, deadline) {
+  return err instanceof TooLate || Date.now() >= deadline ? LATE : err.message;
+}
+
+// accountQuestion is the sign-in's question which Google account to sign in (opts the plugin's):
+// a new one, or one the local service has. null when there is nothing to ask: no service set up,
+// no account in it, or a service not up within waitMs.
+export async function accountQuestion(opts, waitMs = ASK_WAIT_MS) {
+  if (!localStudio(opts)) return null;
+  try {
+    await byDeadline(ensureStudio({ proxy: opts.proxy, managementOnly: true }), Date.now() + waitMs);
+  } catch (err) {
+    if (err instanceof TooLate) return null;
+    throw err;
+  }
+  const accounts = await studioAccounts(opts);
+  if (!accounts.length) return null;
+  return {
+    type: 'select',
+    key: 'account',
+    message: '选择 Google 账号',
+    placeholder: '',
+    options: [
+      { label: '添加新的 Google 账号', value: NEW_ACCOUNT, hint: '打开登录窗口' },
+      ...accounts.map(a => ({
+        label: labelOf(a),
+        value: a.id,
+        hint: a.state === 'auth_required' ? '需要重新登录：会打开登录窗口' : ACCOUNT_STATES[a.state] || a.state || ''
+      }))
+    ]
+  };
+}
+
+// signInProgress opens a progress page for a sign-in with something to wait for that Magpie can't
+// show as it goes (its card shows the instructions authorize gives, and nothing after): the
+// service to set up (serviceUp false), or Camoufox to download. Magpie opens the page as the
+// sign-in's url. null when there is nothing to wait for, or the page can't open; login() says the
+// service is up and the login has begun, end(error) that the sign-in ended.
+export async function signInProgress(serviceUp) {
+  const dataDir = studioDataDir();
+  if (serviceUp && camoufoxState(dataDir).ready) return null;
+  const sign = { at: 'service', error: '' };
+  let page;
+  try {
+    page = await openProgressPage(() => progressSteps(sign, dataDir));
+  } catch (err) {
+    console.error(`[ai-studio] could not open the sign-in progress page: ${err.message}`);
+    return null;
+  }
+  // The first end stands: a step that ends after the sign-in did changes nothing.
+  let ended = false;
+  return {
+    url: page.url,
+    login() {
+      if (!ended) sign.at = 'login';
+    },
+    end(error) {
+      if (ended) return;
+      ended = true;
+      if (error) sign.error = error;
+      else sign.at = 'done';
+      setTimeout(page.close, PAGE_LINGER_MS).unref();
+    }
+  };
+}
+
+// progressSteps is what a sign-in's progress page shows: the service set up, Camoufox downloaded,
+// the login itself, and how far the one under way has got.
+function progressSteps(sign, dataDir) {
+  const steps = [
+    { label: '准备本地 AI Studio 服务', state: 'done' },
+    { label: '准备登录用的浏览器 Camoufox', state: 'pending' },
+    { label: '在弹出的登录窗口里登录 Google 账号', state: 'pending' }
+  ];
+  let current;
+  if (sign.at === 'service') {
+    current = steps[0];
+    const setup = setupStep(dataDir);
+    if (setup?.step === 'download') Object.assign(current, { detail: '正在从 GitHub 下载', received: setup.received, total: setup.total });
+    else current.detail = { install: '正在安装', start: '正在启动' }[setup?.step] ?? '正在检查';
+  } else if (sign.at === 'login') {
+    const camoufox = camoufoxState(dataDir);
+    if (camoufox.ready) {
+      steps[1].state = 'done';
+      current = steps[2];
+      current.detail = '登录窗口是单独弹出的，在里面登录即可，登录完可以关掉它。';
+    } else {
+      current = steps[1];
+      if (camoufox.unpacking) current.detail = '正在解压';
+      else Object.assign(current, { detail: '正在从 GitHub 下载（约 300 MB）', received: camoufox.received, total: camoufox.total });
+    }
+  } else {
+    for (const step of steps) step.state = 'done';
+  }
+  if (current && sign.error) Object.assign(current, { state: 'failed', detail: '没有完成' });
+  else if (current) current.state = 'active';
+  return {
+    note: '这个页面只显示进度，由 Magpie 的 magpie-gemini-web 插件打开；Google 登录在另外弹出的窗口里完成。',
+    steps,
+    done: sign.at === 'done',
+    doneText: '登录完成了，可以关掉这个页面，回到 Magpie。',
+    error: sign.error
+  };
+}
+
 export const AIStudioPlugin = async (_input, options = {}) => {
   const opts = studioSettings(options);
 
@@ -523,26 +660,48 @@ export const AIStudioPlugin = async (_input, options = {}) => {
     }
   }
 
+  // setupNote is a line for a sign-in that must set the service up before its login window can
+  // open: the download (from GitHub, and on Windows not through the system proxy) shows nothing
+  // until it ends, which can take minutes.
+  function setupNote() {
+    let proxy = '';
+    try {
+      proxy = downloadProxy(studioDataDir(), opts.proxy);
+    } catch {}
+    const via = proxy ? `走代理 ${redactProxy(proxy)}` : '直连 GitHub，不走系统代理';
+    return `本地 AI Studio 服务还没启动：要先启动它，第一次使用或插件更新后还要先从 GitHub 下载（约 25 MB，${via}），可能要等几分钟。${SETUP_PROXY_HINT}\n`;
+  }
+
   // addAccount signs a new Google account in through the service's own login window, setting the
-  // service up first if this is the first.
+  // service up first if this is the first. Setting it up waits in the callback, after the
+  // instructions show, so the sign-in doesn't sit without a word while it downloads.
   async function addAccount() {
-    const ready = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
+    const installed = localStudio(opts);
+    const serviceUp = !!installed && (await checkStudioHealth(installed, globalThis.fetch)).state === 'up';
+    const note = serviceUp ? await proxyNote(installed) : '';
+    const progress = await signInProgress(serviceUp);
+    const deadline = Date.now() + SIGN_IN_BUDGET_MS;
     return {
-      url: '',
+      url: progress?.url ?? '',
       method: 'auto',
-      instructions: LOGIN_STEPS + await proxyNote(ready),
+      instructions: (serviceUp ? '' : setupNote()) + (progress ? `${PAGE_LINE}\n` : '') + LOGIN_STEPS + note,
       async callback() {
         let local, account;
         try {
-          local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
-          const res = await studioAdmin(local, 'POST', '/api/accounts', {}, { timeoutMs: LOGIN_TIMEOUT_MS });
+          local = await byDeadline(ensureStudio({ proxy: opts.proxy, managementOnly: true }), deadline);
+          progress?.login();
+          const res = await studioAdmin(local, 'POST', '/api/accounts', {}, { timeoutMs: Math.max(1, deadline - Date.now()) });
           account = res?.account;
           if (!account || typeof account.id !== 'string' || !account.id || account.enabled === false) {
             throw new Error('AIStudio2API did not return an enabled account');
           }
         } catch (err) {
-          return { type: 'failed', error: `Google 登录没有完成：${err.message}${await proxyNote(local)}` };
+          const hint = local ? await proxyNote(local) : `\n${SETUP_PROXY_HINT}`;
+          const error = `Google 登录没有完成：${failedWhy(err, deadline)}${hint}`;
+          progress?.end(error);
+          return { type: 'failed', error };
         }
+        progress?.end();
         return afterLogin(local, account);
       }
     };
@@ -550,19 +709,25 @@ export const AIStudioPlugin = async (_input, options = {}) => {
 
   // signInAgain signs an account whose Google sign-in expired in again, in a login window.
   async function signInAgain(ready, chosen) {
+    const progress = await signInProgress(true);
+    const deadline = Date.now() + SIGN_IN_BUDGET_MS;
     return {
-      url: '',
+      url: progress?.url ?? '',
       method: 'auto',
-      instructions: RELOGIN_STEPS + await proxyNote(ready),
+      instructions: (progress ? `${PAGE_LINE}\n` : '') + RELOGIN_STEPS + await proxyNote(ready),
       async callback() {
         let local;
         try {
-          local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
-          const res = await studioAdmin(local, 'POST', `/api/accounts/${encodeURIComponent(chosen.id)}/login`, {}, { timeoutMs: LOGIN_TIMEOUT_MS });
+          local = await byDeadline(ensureStudio({ proxy: opts.proxy, managementOnly: true }), deadline);
+          progress?.login();
+          const res = await studioAdmin(local, 'POST', `/api/accounts/${encodeURIComponent(chosen.id)}/login`, {}, { timeoutMs: Math.max(1, deadline - Date.now()) });
           if (res?.account?.state === 'auth_required') throw new Error(res.account.message || '账号仍然需要重新登录');
         } catch (err) {
-          return { type: 'failed', error: `${labelOf(chosen)} 没有重新登录：${err.message}${await proxyNote(local)}` };
+          const error = `${labelOf(chosen)} 没有重新登录：${failedWhy(err, deadline)}${await proxyNote(local)}`;
+          progress?.end(error);
+          return { type: 'failed', error };
         }
+        progress?.end();
         return afterLogin(local, chosen);
       }
     };
@@ -588,25 +753,8 @@ export const AIStudioPlugin = async (_input, options = {}) => {
           type: 'oauth',
           label: SIGN_IN_METHOD,
           prompts: [{ type: 'select', key: 'account', message: '选择 Google 账号', options: [] }],
-          async ask(inputs) {
-            if (inputs?.account || !localStudio(opts)) return null;
-            await ensureStudio({ proxy: opts.proxy, managementOnly: true });
-            const accounts = await studioAccounts(opts);
-            if (!accounts.length) return null;
-            return {
-              type: 'select',
-              key: 'account',
-              message: '选择 Google 账号',
-              placeholder: '',
-              options: [
-                { label: '添加新的 Google 账号', value: NEW_ACCOUNT, hint: '打开登录窗口' },
-                ...accounts.map(a => ({
-                  label: labelOf(a),
-                  value: a.id,
-                  hint: a.state === 'auth_required' ? '需要重新登录：会打开登录窗口' : ACCOUNT_STATES[a.state] || a.state || ''
-                }))
-              ]
-            };
+          ask(inputs) {
+            return inputs?.account ? null : accountQuestion(opts);
           },
           async authorize(inputs) {
             const id = inputs?.account;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie-gemini-web",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "description": "Gemini Web and Google AI Studio provider for Magpie, backed by gemini-web2api-go and AIStudio2API",
   "type": "module",
   "main": "./index.mjs",

package/scripts/studio-release.mjs

@@ -52,6 +52,13 @@ try {
   }
   execFileSync('git', ['-C', upstream, 'archive', '--format=tar', `--output=${path.join(scratch, 'upstream.tar')}`, release.upstream.commit]);
   execFileSync('tar', ['-xf', 'upstream.tar', '-C', 'source'], { cwd: scratch });
+  // The plugin tells whether a sign-in will download Camoufox by the version this upstream takes.
+  const camoufox = fs.readFileSync(path.join(source, 'internal/camoufoxnative/download.go'), 'utf8')
+    .match(/const camoufoxRelease = "([^"]+)"/)?.[1];
+  if (!camoufox) throw new Error('Could not find camoufoxRelease in upstream internal/camoufoxnative/download.go');
+  if (camoufox !== release.upstream.camoufox) {
+    throw new Error(`Upstream takes Camoufox ${camoufox}: set upstream.camoufox in lib/studio-release.json to it (now ${release.upstream.camoufox})`);
+  }
   npm(['ci', '--no-audit', '--no-fund']);
   npm(['run', 'lint']);
   npm(['run', 'build']);