magpie-gemini-web 0.5.0 → 0.5.1

package/README.en.md

@@ -87,18 +87,19 @@ Uses Google AI Studio through [AIStudio2API](https://github.com/Mag1cFall/AIStud
 
 ### Getting started
 
-1. Sign in to Google AI Studio and choose **一键配置本地 Google AI Studio（推荐）** (one-click local setup). The plugin downloads AIStudio2API, verifies its SHA-256 and starts it in the background.
-2. Sign in to your Google account in the separate login window that opens (your usual browser is not affected), then close it. The first time, the login browser Camoufox is downloaded first, so the window can take a few minutes to appear; the login must finish within 15 minutes.
+1. Sign in to Google AI Studio and choose **用 Google 账号登录（推荐）** (sign in with a Google account). The first time, the plugin downloads AIStudio2API, verifies its SHA-256 and starts it in the background.
+2. Sign in to your Google account in the separate login window that opens (your usual browser is not affected), then close it. The first time, the login browser Camoufox (about 300 MB) is downloaded first, so the window can take a few minutes to appear while Magpie shows no change; the login must finish within 15 minutes.
 
-To add another account, run the one-click setup again. All accounts share one sign-in card: the local service picks the account for each request, using one until it cools down, then the next.
+Choosing it again later lists:
 
-Other sign-in options:
+- **添加新的 Google 账号** (add a new Google account): opens the login window for another account;
+- **the accounts already on this machine**: makes a card for one at once; one marked as needing to sign in again opens the login window to do so.
 
-- **使用本机已有的 AI Studio 服务** (use the local service already set up): signs in when the machine already has accounts (added from the command line, say), without a login window.
-- **重新登录失效的 AI Studio 账号** (sign an expired account in again): when an account's Google login expires, choose it here to sign in again.
-- **连接已有 AIStudio2API** (connect an existing AIStudio2API): if you run AIStudio2API yourself, enter its address (default `http://127.0.0.1:2048/v1`) and `PROXY_API_KEY`.
+Each Google account gets a card of its own. As with Gemini Web, the local service picks the account for each request (one until it cools down, then the next), whichever card Magpie uses.
 
-Usage card: AI Studio reports no remaining quota, so the card shows the pool's accounts and the models they are cooling down on. Each model gets a meter; a full one means no account can use it for now, with the time it comes back.
+If you run AIStudio2API yourself, choose **连接已有 AIStudio2API** (connect an existing AIStudio2API) and enter its address (default `http://127.0.0.1:2048/v1`) and `PROXY_API_KEY`.
+
+Usage card: AI Studio reports no remaining quota. The card shows the models the account is cooling down on and when each comes back, or that the account needs to sign in again.
 
 ### Plugin options
 

package/README.md

@@ -87,18 +87,19 @@ Magpie 的额度卡片会显示 Google 账号的 **5 小时** 和 **每周** 用
 
 ### 开始使用
 
-1. 登录 Google AI Studio，选 **「一键配置本地 Google AI Studio（推荐）」**。插件会自动下载 AIStudio2API、校验 SHA-256 并在后台启动。
-2. 在弹出的独立登录窗口里登录 Google 账号（不影响你平时用的浏览器），完成后关掉窗口即可。第一次要先下载登录用的浏览器 Camoufox，窗口可能要等几分钟才出现；需要在 15 分钟内完成登录。
+1. 登录 Google AI Studio，选 **「用 Google 账号登录（推荐）」**。第一次用时，插件会自动下载 AIStudio2API、校验 SHA-256 并在后台启动。
+2. 在弹出的独立登录窗口里登录 Google 账号（不影响你平时用的浏览器），完成后关掉窗口即可。第一次要先下载登录用的浏览器 Camoufox（约 300 MB），窗口可能要等几分钟才出现，期间 Magpie 里没有变化；需要在 15 分钟内完成登录。
 
-想加更多账号，再走一遍一键配置。所有账号共用一张登录卡片：每个请求用哪个账号由本地服务决定，先用一个，冷却了再换下一个。
+之后再选「用 Google 账号登录」，会列出：
 
-其他登录选项：
+- **添加新的 Google 账号**：打开登录窗口，再加一个账号；
+- **本机已有的账号**：直接给它建卡片；标着「需要重新登录」的账号会打开登录窗口重新登录。
 
-- **使用本机已有的 AI Studio 服务**：本机已经有账号（比如用命令行添加的）时直接登录，不打开登录窗口。
-- **重新登录失效的 AI Studio 账号**：账号的 Google 登录过期后，在这里选中它重新登录。
-- **连接已有 AIStudio2API**：你自己运行了 AIStudio2API 时，填它的地址（默认 `http://127.0.0.1:2048/v1`）和 `PROXY_API_KEY`。
+每个 Google 账号一张卡片。和 Gemini Web 一样，每个请求实际用哪个账号由本地服务决定（先用一个，冷却了再换下一个），Magpie 在卡片之间怎么切换不影响这一点。
 
-额度卡片：AI Studio 不提供剩余额度，卡片显示账号池里的账号和正在冷却的模型。每个模型一条进度条，满格表示暂时没有账号能用它，旁边是恢复时间。
+如果你自己运行了 AIStudio2API，选 **「连接已有 AIStudio2API」**，填它的地址（默认 `http://127.0.0.1:2048/v1`）和 `PROXY_API_KEY`。
+
+额度卡片：AI Studio 不提供剩余额度。卡片显示这个账号正在冷却的模型和恢复时间；账号需要重新登录时会提示。
 
 ### 插件选项
 

package/lib/studio-native.mjs

@@ -860,7 +860,7 @@ async function readyStudio(local, initial, options = {}) {
   for (;;) {
     if (status.running) return local;
     if (needsSignIn(status.accounts)) {
-      throw new Error(`AI Studio cannot start: its Google accounts need to sign in again (${status.accounts.auth_required} of ${status.accounts.total}). In Magpie, sign in to AI Studio with "重新登录失效的 AI Studio 账号", or run: ${studioCommand('relogin')}`);
+      throw new Error(`AI Studio cannot start: its Google accounts need to sign in again (${status.accounts.auth_required} of ${status.accounts.total}). In Magpie, sign in to Google AI Studio with "用 Google 账号登录（推荐）" and choose the account, or run: ${studioCommand('relogin')}`);
     }
     if (Date.now() >= deadline) {
       throw new Error(`AI Studio generation did not become ready (state ${status.state}, ${status.accounts.ready ?? 0}/${status.accounts.total} accounts ready); see ${path.join(local.dataDir, 'backend.log')}`);

package/lib/studio.mjs

@@ -15,18 +15,28 @@ const LOGIN_TIMEOUT_MS = 15 * 60 * 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 = [
-  '即将打开独立的 Google 登录窗口（不影响你平时用的浏览器）。',
-  '第一次登录要先下载登录用的浏览器 Camoufox，可能要等几分钟窗口才出现。',
-  '请在 15 分钟内完成登录；登录完成后可以关掉窗口，日常生成不需要浏览器。'
+  '第一次登录要先下载登录用的浏览器 Camoufox（约 300 MB），可能要等几分钟窗口才出现，期间这里没有变化，请耐心等待。',
+  '登录窗口是独立的，不影响你平时用的浏览器；请在 15 分钟内完成登录，完成后可以关掉窗口，日常生成不需要浏览器。'
 ];
 const LOGIN_STEPS = [
   ...LOGIN_WINDOW,
-  '已经配置过也可以再来一次，添加更多 Google 账号：所有账号共用这一个登录，由本地服务自动轮换。'
+  '想加更多 Google 账号，再来一次即可，每个账号一张卡片。'
 ].join('\n');
 const RELOGIN_STEPS = LOGIN_WINDOW.join('\n');
-const SETUP_METHOD = '一键配置本地 Google AI Studio（推荐）';
-const RELOGIN_METHOD = '重新登录失效的 AI Studio 账号';
-const NO_LOCAL_STUDIO = `还没有本地 Google AI Studio 服务：请先用「${SETUP_METHOD}」`;
+// AdminAccount.state as the account list shows it
+const ACCOUNT_STATES = {
+  ready: '可用',
+  busy: '使用中',
+  cooldown: '冷却中',
+  auth_required: '需要重新登录',
+  unavailable: '暂时不可用',
+  disabled: '已停用'
+};
+const SIGN_IN_METHOD = '用 Google 账号登录（推荐）';
+// How to sign an account in again, or add one, as messages say it
+const SIGN_IN_HOW = `在 Magpie 里登录 Google AI Studio，选「${SIGN_IN_METHOD}」`;
+// The choice of a new account among the local service's (whose ids are emails, so none is this)
+const NEW_ACCOUNT = '+new';
 
 const KNOWN_STUDIO_NESTED = new Set([
   'baseURL',
@@ -342,15 +352,16 @@ async function forwardManagedStudio(input, init, getAuth, opts) {
   return forward(retryInput, init, getAuth, { ...opts, nativeThinking: true, stripCitations: false });
 }
 
-// poolSignIn is the Magpie sign-in for the local service: its key, which serves every account
-// signed in to it. The service picks the account for each request itself (fill-first), so a
-// sign-in can't pin one, and none is named: Magpie takes two sign-ins with no email and the same
-// key for one, so signing in again, as adding another account does, keeps the one card.
-function poolSignIn(local) {
+// accountSignIn is the Magpie sign-in for one Google account of the local service: the service's
+// key, with the account's id for its usage card and its email (the account's label, or its id,
+// which upstream makes the lowercased email), which names the card and keeps each account a
+// sign-in of its own, as Gemini Web's are. The service still picks the account for each request
+// itself (fill-first): a sign-in can't pin one.
+function accountSignIn(local, account) {
   return {
     type: 'success',
     key: local.apiKey,
-    metadata: { mode: 'studio', managed: true, baseURL: local.baseURL }
+    metadata: { mode: 'studio', managed: true, baseURL: local.baseURL, account: account.id, email: labelOf(account) }
   };
 }
 
@@ -390,13 +401,40 @@ export function cooldownWindows(cooldowns, accounts, now = Date.now()) {
   return out.sort((a, b) => b.used - a.used || Date.parse(a.resetsAt) - Date.parse(b.resetsAt));
 }
 
+// accountUsage is the usage card of one account of the local service: its own cooldowns, one
+// window a model (or one for all its models), full until the cooldown ends; an account that can't
+// serve says why instead.
+export function accountUsage(account, cooldowns, now = Date.now()) {
+  const user = labelOf(account);
+  if (account.state === 'auth_required') {
+    return { user, error: `这个 Google 账号需要重新登录：${SIGN_IN_HOW}，再选这个账号`, windows: [] };
+  }
+  if (!SERVING_STATES.has(account.state)) {
+    const why = ACCOUNT_STATES[account.state] || account.state || '暂时不可用';
+    return { user, error: `这个 Google 账号${why}${account.message ? `：${account.message}` : ''}`, windows: [] };
+  }
+  const windows = [];
+  for (const c of cooldowns) {
+    const until = Date.parse(c?.until ?? '');
+    if (c?.account_id !== account.id || !Number.isFinite(until) || until <= now) continue;
+    const reason = typeof c.reason === 'string' ? c.reason.trim() : '';
+    windows.push({
+      name: typeof c.model_id === 'string' && c.model_id ? c.model_id : '所有模型',
+      used: 100,
+      resetsAt: new Date(until).toISOString(),
+      display: reason && reason.length <= 40 ? `冷却中：${reason}` : '冷却中'
+    });
+  }
+  return { user, windows: windows.sort((a, b) => Date.parse(a.resetsAt) - Date.parse(b.resetsAt)) };
+}
+
 // poolUsage is the usage card of the local service's accounts: they go by their labels (Google
 // emails), with the ones that can't serve counted beside them. The service gives no allowance to
 // show, only the models its accounts cool down on (see cooldownWindows); a pool none of whose
 // accounts can serve until one signs in again is an error, since every request fails.
 export function poolUsage(accounts, cooldowns, now = Date.now()) {
   if (!accounts.length) {
-    return { error: `本地 AI Studio 里还没有 Google 账号：在 Magpie 里登录 AI Studio，选「${SETUP_METHOD}」`, windows: [] };
+    return { error: `本地 AI Studio 里还没有 Google 账号：${SIGN_IN_HOW}`, windows: [] };
   }
   const expired = accounts.filter(a => a.state === 'auth_required').length;
   const unavailable = accounts.filter(a => a.state === 'unavailable').length;
@@ -407,7 +445,7 @@ export function poolUsage(accounts, cooldowns, now = Date.now()) {
   const user = notes.length ? `${named}（${notes.join('，')}）` : named;
   if (!accounts.some(a => SERVING_STATES.has(a.state))) {
     const error = expired
-      ? `${expired} 个 Google 账号都需要重新登录：在 Magpie 里登录 AI Studio，选「${RELOGIN_METHOD}」`
+      ? `${expired} 个 Google 账号都需要重新登录：${SIGN_IN_HOW}，再选要重新登录的账号`
       : '本地 AI Studio 的 Google 账号暂时都不可用';
     return { user, error, windows: [] };
   }
@@ -426,20 +464,56 @@ export const AIStudioPlugin = async (_input, options = {}) => {
   // afterLogin is the sign-in once an account is signed in. Generation may still be starting;
   // the first request waits for it, so a slow start doesn't fail a sign-in that worked (and a
   // retry doesn't open another login window for the same account).
-  function afterLogin(local) {
+  function afterLogin(local, account) {
     ensureStudio({ proxy: opts.proxy }).catch(err => {
       console.error(`[ai-studio] generation did not start after sign-in: ${err.message}`);
     });
-    return poolSignIn(local);
+    return accountSignIn(local, account);
   }
 
-  // expiredAccounts is the enabled accounts that need to sign in again, of a setup already here.
-  async function expiredAccounts() {
-    if (!localStudio(opts)) throw new Error(NO_LOCAL_STUDIO);
+  // addAccount signs a new Google account in through the service's own login window, setting the
+  // service up first if this is the first.
+  async function addAccount() {
     await ensureStudio({ proxy: opts.proxy, managementOnly: true });
-    const accounts = (await studioAccounts(opts)).filter(a => a.state === 'auth_required');
-    if (!accounts.length) throw new Error('本地 Google AI Studio 里没有需要重新登录的账号');
-    return accounts;
+    return {
+      url: '',
+      method: 'auto',
+      instructions: LOGIN_STEPS,
+      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 });
+          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}` };
+        }
+        return afterLogin(local, account);
+      }
+    };
+  }
+
+  // signInAgain signs an account whose Google sign-in expired in again, in a login window.
+  function signInAgain(chosen) {
+    return {
+      url: '',
+      method: 'auto',
+      instructions: RELOGIN_STEPS,
+      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 });
+          if (res?.account?.state === 'auth_required') throw new Error(res.account.message || '账号仍然需要重新登录');
+        } catch (err) {
+          return { type: 'failed', error: `${labelOf(chosen)} 没有重新登录：${err.message}` };
+        }
+        return afterLogin(local, chosen);
+      }
+    };
   }
 
   return {
@@ -457,83 +531,39 @@ export const AIStudioPlugin = async (_input, options = {}) => {
       maxConcurrency: 1,
       methods: [
         {
+          // One way in for a Google account: a new one, one the local service already has, or one
+          // of those to sign in again. The first time there is no service yet, and nothing to ask.
           type: 'oauth',
-          label: SETUP_METHOD,
-          async authorize() {
+          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 });
-            return {
-              url: '',
-              method: 'auto',
-              instructions: LOGIN_STEPS,
-              async callback() {
-                let local;
-                try {
-                  local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
-                  const res = await studioAdmin(local, 'POST', '/api/accounts', {}, { timeoutMs: LOGIN_TIMEOUT_MS });
-                  const 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}` };
-                }
-                return afterLogin(local);
-              }
-            };
-          }
-        },
-        {
-          type: 'oauth',
-          label: '使用本机已有的 AI Studio 服务',
-          async authorize() {
-            // Only a setup that is already here has accounts to use: don't install one.
-            if (!localStudio(opts)) throw new Error(NO_LOCAL_STUDIO);
-            const local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
             const accounts = await studioAccounts(opts);
-            if (!accounts.length) throw new Error(`本地 Google AI Studio 里没有启用的 Google 账号：请用「${SETUP_METHOD}」添加`);
-            return {
-              url: '',
-              method: 'auto',
-              instructions: '',
-              callback: async () => poolSignIn(local)
-            };
-          }
-        },
-        {
-          type: 'oauth',
-          label: RELOGIN_METHOD,
-          prompts: [{ type: 'select', key: 'account', message: '选择要重新登录的 Google 账号', options: [] }],
-          async ask(inputs) {
-            if (inputs?.account) return null;
-            const accounts = await expiredAccounts();
+            if (!accounts.length) return null;
             return {
               type: 'select',
               key: 'account',
-              message: '选择要重新登录的 Google 账号',
+              message: '选择 Google 账号',
               placeholder: '',
-              options: accounts.map(a => ({ label: labelOf(a), value: a.id, hint: a.message || '需要重新登录' }))
+              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 || ''
+                }))
+              ]
             };
           },
           async authorize(inputs) {
-            const accounts = await expiredAccounts();
-            const chosen = accounts.find(a => a.id === inputs?.account);
-            if (!chosen) throw new Error(`账号 ${inputs?.account ?? ''} 不需要重新登录`);
-            return {
-              url: '',
-              method: 'auto',
-              instructions: RELOGIN_STEPS,
-              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 });
-                  if (res?.account?.state === 'auth_required') throw new Error(res.account.message || '账号仍然需要重新登录');
-                } catch (err) {
-                  return { type: 'failed', error: `${labelOf(chosen)} 没有重新登录：${err.message}` };
-                }
-                return afterLogin(local);
-              }
-            };
+            const id = inputs?.account;
+            if (!id || id === NEW_ACCOUNT) return addAccount();
+            const local = await ensureStudio({ proxy: opts.proxy, managementOnly: true });
+            const chosen = (await studioAccounts(opts)).find(a => a.id === id);
+            if (!chosen) throw new Error(`本地 Google AI Studio 里没有启用的账号 ${id}`);
+            if (chosen.state === 'auth_required') return signInAgain(chosen);
+            return { url: '', method: 'auto', instructions: '', callback: async () => accountSignIn(local, chosen) };
           }
         },
         {
@@ -614,7 +644,16 @@ export const AIStudioPlugin = async (_input, options = {}) => {
         }
         const enabled = (Array.isArray(accounts?.accounts) ? accounts.accounts : []).filter(a => a && a.enabled !== false);
         const cooling = Array.isArray(cooldowns?.cooldowns) ? cooldowns.cooldowns : [];
-        return { ...poolUsage(enabled, cooling), signIn: 'kept' };
+        const id = auth.metadata.account;
+        if (typeof id !== 'string' || !id) {
+          // A sign-in for the whole pool, as 0.5.0 made them
+          return { ...poolUsage(enabled, cooling), signIn: 'kept' };
+        }
+        const account = enabled.find(a => a.id === id);
+        if (!account) {
+          return { error: `本地 AI Studio 里已经没有这个账号（${auth.metadata.email || id}），可能被停用或删除了`, windows: [], signIn: 'kept' };
+        }
+        return { ...accountUsage(account, cooling), signIn: 'kept' };
       }
     },
     provider: {

package/package.json

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