magpie-gemini-web 0.5.3 → 0.5.5

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

@@ -1,38 +1,39 @@
 {
-  "version": "0.2.13-magpie.1",
+  "version": "0.2.14-magpie.1",
   "repository": "BUKOWSKIREAL/magpie-gemini-web",
-  "tag": "studio-v0.2.13-magpie.1",
+  "tag": "studio-v0.2.14-magpie.1",
   "goVersion": "1.27.1",
   "upstream": {
-    "version": "0.2.13",
+    "version": "0.2.14",
     "repository": "https://github.com/Mag1cFall/AIStudio2API.git",
-    "commit": "a784c5193b3ba5c4894d536b2f4cd73e87f99475"
+    "commit": "370a313814099b508881807effa2a9d72f2d7e66",
+    "camoufox": "152.0.4-beta.29"
   },
   "binaries": {
     "darwin-arm64": {
-      "asset": "aistudio2api-v0.2.13-magpie.1-darwin-arm64.tar.gz",
-      "sha256": "3145f1fc3e88dafc1c43ecfa4ed7c6f82d1126a2d8add02605d05f1c5c404144",
-      "binarySha256": "7d727bf1cc5a86d9c1a2a99d73d645f38a0597489ef62e2bf20b0d33dd87369d"
+      "asset": "aistudio2api-v0.2.14-magpie.1-darwin-arm64.tar.gz",
+      "sha256": "f649c21837741bdb448407f79a3bc998429b446408ef3117a897103b9a47ee72",
+      "binarySha256": "999e49572dede3a63f538e3f62ceed5f03349459bdf391fd49fd57784985e13b"
     },
     "darwin-x64": {
-      "asset": "aistudio2api-v0.2.13-magpie.1-darwin-amd64.tar.gz",
-      "sha256": "96994351570105a6de4e1c95800231ad20d762ee010cfa238bfef11101124c27",
-      "binarySha256": "428963b5bd3c9c35b88c7a7f29923c5a5a6bef5d0fcd511274daa8a8ebc9f686"
+      "asset": "aistudio2api-v0.2.14-magpie.1-darwin-amd64.tar.gz",
+      "sha256": "ece680b5dfef57b0b0e96d639b618b74570e6e194f58808d762da85fd41d9b4a",
+      "binarySha256": "970df3ac51719721d908162d0233d80711f6c3ee007e193d0a73b6e4e596ca9a"
     },
     "linux-x64": {
-      "asset": "aistudio2api-v0.2.13-magpie.1-linux-amd64.tar.gz",
-      "sha256": "9e24fb139abb0bcd8f6cbab23ac1875136f3ecacd30919fbcc25fe342feb369c",
-      "binarySha256": "de8c25f07870d83dd2ebc03b9be1f6e15b4f93f454dfe8f5c4182c72261bcbfa"
+      "asset": "aistudio2api-v0.2.14-magpie.1-linux-amd64.tar.gz",
+      "sha256": "f6c7b52a739e4534236f055280fcddd48e64b56fdb954a7844eb453226d5b67f",
+      "binarySha256": "316306225bcc343188d6d81635d4bd79e7e82bd5c51b1009cd25361deb3b5e61"
     },
     "linux-arm64": {
-      "asset": "aistudio2api-v0.2.13-magpie.1-linux-arm64.tar.gz",
-      "sha256": "7b7057abd8e298685f4ca835e014a48c9b1904a253ebfbc053e4b1d7712c532c",
-      "binarySha256": "151fd830cf0da8801d49e448021d73cde0adb51e982b3a8604cdcbc5babd21c4"
+      "asset": "aistudio2api-v0.2.14-magpie.1-linux-arm64.tar.gz",
+      "sha256": "a5b838b9b64e78d402372cae6b88e1f3faba406747e598e976728c71da3a75ef",
+      "binarySha256": "a5e9573b9edad7fb246178fb4c3d21a0d4905789fd59abf96656d57f26b7526e"
     },
     "win32-x64": {
-      "asset": "aistudio2api-v0.2.13-magpie.1-windows-amd64.zip",
-      "sha256": "aa337556362ce9c16cae71117a9c12e20b623b12665dd5f36cf01bf152d72fbb",
-      "binarySha256": "4a0c32be722dcc27c9046fe410d6af7efd576c4192cb1158c84468cada4fbd30"
+      "asset": "aistudio2api-v0.2.14-magpie.1-windows-amd64.zip",
+      "sha256": "ccd5b96dabebbc0f1d510959c698beb9d9af09bb65d8b0e021327970b3173384",
+      "binarySha256": "ce784c98f1558395a670421ef6cc7d36dde5313f74788f7df5772851c241ae06"
     }
   }
 }

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.3",
+  "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-managed-smoke.mjs

@@ -25,6 +25,7 @@ try {
   for (const query of ['', '?refresh=1']) {
     const update = await studioAdmin(local, 'GET', `/api/update${query}`);
     assert.equal(update.mode, 'managed');
+    assert.equal(update.managed_by, 'magpie-gemini-web');
     assert.equal(update.available, false);
     assert.equal(update.updating, false);
     assert.equal(update.current, STUDIO_VERSION);
@@ -36,8 +37,8 @@ try {
       if (String(args[0]).endsWith('/api/update')) updateHTTP = response.status;
       return response;
     }
-  }), /Magpie/);
-  assert.equal(updateHTTP, 403);
+  }), /magpie-gemini-web/);
+  assert.equal(updateHTTP, 409);
   assert.equal(computeFileHash(bin), pin.binarySha256, 'update must not replace the binary');
   assert.equal(fs.readFileSync(path.join(dataDir, 'backend.pid'), 'utf8'), pidBefore, 'update must not restart');
   const html = await (await fetch(local.origin)).text();
@@ -47,11 +48,12 @@ try {
   const versionPanel = /(?:\.\/|\/assets\/)?(VersionPanel-[\w-]+\.js)/.exec(js)?.[1];
   assert.ok(versionPanel, 'built admin version panel must exist');
   const panel = await (await fetch(`${local.origin}/assets/${versionPanel}`)).text();
-  assert.match(panel, /Online updates are disabled/);
-  assert.ok(!panel.includes('applyUpdate'), 'version panel must not offer online installation');
+  // Upstream's panel keeps its install button for other builds and shows a managed build's note
+  // in its place; the refusal above is what keeps the binary
+  assert.match(panel, /version\.managed/);
   assert.deepEqual(await stopStudio({ dataDir }), { stopped: true });
   assert.equal((await studioStatus({ dataDir })).status, 'stopped');
-  console.log(`PASS ${key}: ${STUDIO_VERSION}, managed status, update HTTP 403, unchanged executable/PID, managed UI, clean stop`);
+  console.log(`PASS ${key}: ${STUDIO_VERSION}, managed status, update HTTP 409, unchanged executable/PID, managed UI, clean stop`);
 } finally {
   let stopped = !local;
   if (local) stopped = (await stopStudio({ dataDir }).catch(() => ({ stopped: false }))).stopped;

package/scripts/studio-release.mjs

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
-// Clean upstream commit + reviewed patch -> managed archives, never a developer's dirty tree.
+// Clean upstream commit -> managed archives, never a developer's dirty tree. Upstream's own
+// distributor settings make the build managed: it reports this version, and its online updater
+// neither checks GitHub nor installs, saying the plugin manages updates.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -34,9 +36,9 @@ const hash = file => crypto.createHash('sha256').update(fs.readFileSync(file)).d
 const go = (argv, extra = {}) => execFileSync('go', argv, { cwd: source, env: { ...env, ...extra }, stdio: 'inherit' });
 const npm = argv => execFileSync(process.platform === 'win32' ? 'npm.cmd' : 'npm', argv,
   { cwd: path.join(source, 'web'), stdio: 'inherit', shell: process.platform === 'win32' });
-const patch = path.join(root, 'patches/studio-managed.patch');
+const MANAGED_BY = 'magpie-gemini-web';
 const flags = ['-mod=readonly', '-trimpath', '-buildvcs=false',
-  `-ldflags=-s -w -X github.com/Mag1cFall/AIStudio2API/internal/app.managedVersion=v${release.version}`];
+  `-ldflags=-s -w -X github.com/Mag1cFall/AIStudio2API/internal/app.version=v${release.version} -X github.com/Mag1cFall/AIStudio2API/internal/app.managedBy=${MANAGED_BY}`];
 
 try {
   let upstream = args.find(arg => arg.startsWith('--source='))?.slice(9);
@@ -50,8 +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 });
-  execFileSync('git', ['apply', '--check', patch], { cwd: source, stdio: 'inherit' });
-  execFileSync('git', ['apply', patch], { cwd: source, stdio: 'inherit' });
+  // 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']);
@@ -74,7 +81,7 @@ try {
   fs.copyFileSync(path.join(source, 'LICENSE'), path.join(output, 'LICENSE-AISTUDIO'));
   fs.writeFileSync(path.join(output, target ? `build-${target}.json` : 'build.json'), JSON.stringify({
     version: release.version, upstream: release.upstream, goVersion: release.goVersion,
-    nodeVersion: process.version, patchSha256: hash(patch), flags, binaries
+    nodeVersion: process.version, managedBy: MANAGED_BY, flags, binaries
   }, null, 2) + '\n');
   fs.writeFileSync(path.join(output, target ? `SHA256SUMS-${target}.txt` : 'SHA256SUMS.txt'),
     Object.values(binaries).map(pin => `${pin.sha256}  ${pin.asset}\n`).join(''));